file_name
stringlengths
3
137
prefix
stringlengths
0
918k
suffix
stringlengths
0
962k
middle
stringlengths
0
812k
header.rs
// Vorbis decoder written in Rust // // Copyright (c) 2016 est31 <[email protected]> // and contributors. All rights reserved. // Licensed under MIT license, or Apache 2 license, // at your option. Please see the LICENSE file // attached to this source distribution for details. /*! Header decoding This module takes care of decoding of the three vorbis headers: 1. Identification 2. Comment 3. Setup It builds only on the internal bitpacking layer and the internal huffman tree handling mod. Everything else about the headers is decoded in this mod. */ use std::error; use std::fmt; use ::bitpacking::BitpackCursor; use ::huffman_tree::{VorbisHuffmanTree, HuffmanError}; use std::io::{Cursor, ErrorKind, Read, Error}; use byteorder::{ReadBytesExt, LittleEndian}; use std::string::FromUtf8Error; use header_cached::{CachedBlocksizeDerived, compute_bark_map_cos_omega}; /// Errors that can occur during Header decoding #[derive(Debug)] #[derive(PartialEq)] pub enum HeaderReadError { EndOfPacket, /// If the passed data don't start with the "vorbis" /// capture pattern, this error is returned. NotVorbisHeader, UnsupportedVorbisVersion, /// If the header violates the vorbis spec HeaderBadFormat, /// The given packet indeed seems to be a vorbis header, /// but it looks like it is a different header type than /// the function it was passed to. /// /// It is not guaranteed that the type is a valid header type. HeaderBadType(u8), /// The given packet does not seem to be a header as per vorbis spec, /// instead it seems to be an audio packet. HeaderIsAudio, Utf8DecodeError, /// If the needed memory isn't addressable by us /// /// This error is returned if a calculation yielded a higher value for /// an internal buffer size that doesn't fit into the platform's address range. /// Note that if we "simply" encounter an allocation failure (OOM, etc), /// we do what libstd does in these cases: crash. /// /// This error is not automatically an error of the passed data, /// but rather is due to insufficient decoder hardware. BufferNotAddressable, } // For the () error type returned by the bitpacking layer // TODO that type choice was a bit unfortunate, // perhaps one day fix this impl From<()> for HeaderReadError { fn from(_ :()) -> HeaderReadError { HeaderReadError::EndOfPacket } } impl From<HuffmanError> for HeaderReadError { fn from(_ :HuffmanError) -> HeaderReadError
} impl From<Error> for HeaderReadError { fn from(err :Error) -> HeaderReadError { match err.kind() { ErrorKind::UnexpectedEof => HeaderReadError::EndOfPacket, _ => panic!("Non EOF Error occured when reading from Cursor<&[u8]>: {}", err), } } } impl From<FromUtf8Error> for HeaderReadError { fn from(_ :FromUtf8Error) -> HeaderReadError { HeaderReadError::Utf8DecodeError } } impl error::Error for HeaderReadError { fn description(&self) -> &str { match self { &HeaderReadError::EndOfPacket => "End of packet reached.", &HeaderReadError::NotVorbisHeader => "The packet is not a vorbis header", &HeaderReadError::UnsupportedVorbisVersion => "The vorbis version is not supported", &HeaderReadError::HeaderBadFormat => "Invalid header", &HeaderReadError::HeaderBadType(_) => "Invalid/unexpected header type", &HeaderReadError::HeaderIsAudio => "Packet seems to be audio", &HeaderReadError::Utf8DecodeError => "UTF-8 decoding error", &HeaderReadError::BufferNotAddressable => "Requested to create buffer of non-addressable size", } } } impl fmt::Display for HeaderReadError { fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { write!(fmt, "{}", error::Error::description(self)) } } /// Macro to convert values of any unsigned integral non-usize type to /// usize, and then check whether there had been any losses due to conversion. /// /// If there were, it will return the BufferNotAddressable error. macro_rules! convert_to_usize { ( $val:expr, $val_type:ident ) => { { let converted :usize = $val as usize; if $val != converted as $val_type { try!(Err(HeaderReadError::BufferNotAddressable)); } converted }} } // Internal function, tries to find out whether the // data returned by rdr belong to a vorbis header // On success it returns Some(n) with n as packet type // (you must check that n from 1,3,5) macro_rules! read_header_begin_body { ( $rdr:expr ) => { { let res = try!($rdr.read_u8()); if res & 1 == 0 { // This is an audio packet per vorbis spec, if anything. // (audio packets have their first bit set to 0, // header packets have it set to 1) try!(Err(HeaderReadError::HeaderIsAudio)); } let is_vorbis = try!($rdr.read_u8()) == 0x76 && // 'v' try!($rdr.read_u8()) == 0x6f && // 'o' try!($rdr.read_u8()) == 0x72 && // 'r' try!($rdr.read_u8()) == 0x62 && // 'b' try!($rdr.read_u8()) == 0x69 && // 'i' try!($rdr.read_u8()) == 0x73; // 's' if !is_vorbis { try!(Err(HeaderReadError::NotVorbisHeader)); } return Ok(res); }} } fn read_header_begin(rdr :&mut BitpackCursor) -> Result<u8, HeaderReadError> { read_header_begin_body!(rdr) } fn read_header_begin_cursor(rdr :&mut Cursor<&[u8]>) -> Result<u8, HeaderReadError> { read_header_begin_body!(rdr) } #[test] fn test_read_hdr_begin() { // Only tests flawed header begins, correct headers // are tested later by the test methods for the headers // Flawed ident header (see char before the /**/) let test_arr = &[0x01, 0x76, 0x6f, 0x72, 0x62, 0x69, 0x72, /**/ 0x00, 0x00, 0x00, 0x00, 0x02, 0x44, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xb5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x01]; let mut rdr :BitpackCursor = BitpackCursor::new(test_arr); assert_eq!(read_header_begin(&mut rdr), Err(HeaderReadError::NotVorbisHeader)); } /// The set of the three Vorbis headers pub type HeaderSet = (IdentHeader, CommentHeader, SetupHeader); /** Representation for the identification header The identification header is the first of the three headers inside each vorbis stream. It covers basic information about the stream. */ pub struct IdentHeader { /// The number of audio channels in the stream pub audio_channels :u8, /// The sample rate of the stream pub audio_sample_rate :u32, /// The maximum bit rate of the stream /// /// Note that this value is only a hint /// and may be off by a large amount. pub bitrate_maximum :i32, /// The nominal bit rate of the stream /// /// Note that this value is only a hint /// and may be off by a large amount. pub bitrate_nominal :i32, /// The minimum bit rate of the stream /// /// Note that this value is only a hint /// and may be off by a large amount. pub bitrate_minimum :i32, pub blocksize_0 :u8, pub blocksize_1 :u8, pub(crate) cached_bs_derived :[CachedBlocksizeDerived; 2], } /** Reading the Identification header If it returns Err(sth) when being called with the first packet in a stream, the whole stream is to be considered undecodable as per the Vorbis spec. The function returns Err(`HeaderReadError::HeaderBadType`) if the header type doesn't match the ident header. */ pub fn read_header_ident(packet :&[u8]) -> Result<IdentHeader, HeaderReadError> { let mut rdr = BitpackCursor::new(packet); let hd_id = try!(read_header_begin(&mut rdr)); if hd_id != 1 { try!(Err(HeaderReadError::HeaderBadType(hd_id))); } let vorbis_version = try!(rdr.read_u32()); if vorbis_version != 0 { try!(Err(HeaderReadError::UnsupportedVorbisVersion)); } let audio_channels = try!(rdr.read_u8()); let audio_sample_rate = try!(rdr.read_u32()); let bitrate_maximum = try!(rdr.read_i32()); let bitrate_nominal = try!(rdr.read_i32()); let bitrate_minimum = try!(rdr.read_i32()); let blocksize_0 = try!(rdr.read_u4()); let blocksize_1 = try!(rdr.read_u4()); let framing = try!(rdr.read_u8()); if blocksize_0 < 6 || blocksize_0 > 13 || blocksize_1 < 6 || blocksize_1 > 13 || (framing != 1) || blocksize_0 > blocksize_1 || audio_channels == 0 || audio_sample_rate == 0 { try!(Err(HeaderReadError::HeaderBadFormat)); } let hdr :IdentHeader = IdentHeader { audio_channels, audio_sample_rate, bitrate_maximum, bitrate_nominal, bitrate_minimum, blocksize_0, blocksize_1, cached_bs_derived : [ CachedBlocksizeDerived::from_blocksize(blocksize_0), CachedBlocksizeDerived::from_blocksize(blocksize_1), ], }; return Ok(hdr); } #[test] fn test_read_header_ident() { // Valid ident header let test_arr = &[0x01, 0x76, 0x6f, 0x72, 0x62, 0x69, 0x73, 0x00, 0x00, 0x00, 0x00, 0x02, 0x44, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xb5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x01]; let hdr = read_header_ident(test_arr).unwrap(); assert_eq!(hdr.audio_channels, 2); assert_eq!(hdr.audio_sample_rate, 0x0000ac44); assert_eq!(hdr.bitrate_maximum, 0); assert_eq!(hdr.bitrate_nominal, 0x0001b580); assert_eq!(hdr.bitrate_minimum, 0); assert_eq!(hdr.blocksize_0, 8); assert_eq!(hdr.blocksize_1, 11); } /** Representation of the comment header The comment header is the second of the three headers inside each vorbis stream. It contains text comment metadata about the stream, encoded as key-value pairs, and the vendor name. */ #[derive(Clone, PartialEq, Eq, Hash, Debug)] pub struct CommentHeader { /// An identification string of the /// software/library that encoded /// the stream. pub vendor :String, /// A key-value list of the comments /// attached to the stream. pub comment_list :Vec<(String, String)>, } /** Reading the Comment header You should call this function with the second packet in the stream. The function does not check whether the comment field names consist of characters `0x20` through `0x7D` (`0x3D` excluded), as the vorbis spec requires. */ pub fn read_header_comment(packet :&[u8]) -> Result<CommentHeader, HeaderReadError> { let mut rdr = Cursor::new(packet); let hd_id = try!(read_header_begin_cursor(&mut rdr)); if hd_id != 3 { try!(Err(HeaderReadError::HeaderBadType(hd_id))); } // First read the vendor string let vendor_length = try!(rdr.read_u32::<LittleEndian>()) as usize; let mut vendor_buf = vec![0; vendor_length]; // TODO fix this, we initialize memory for NOTHING!!! Out of some reason, this is seen as "unsafe" by rustc. try!(rdr.read_exact(&mut vendor_buf)); let vendor = try!(String::from_utf8(vendor_buf)); // Now read the comments let comment_count = try!(rdr.read_u32::<LittleEndian>()) as usize; let mut comment_list = Vec::with_capacity(comment_count); for _ in 0 .. comment_count { let comment_length = try!(rdr.read_u32::<LittleEndian>()) as usize; let mut comment_buf = vec![0; comment_length]; // TODO fix this, we initialize memory for NOTHING!!! Out of some reason, this is seen as "unsafe" by rustc. try!(rdr.read_exact(&mut comment_buf)); let comment = match String::from_utf8(comment_buf) { Ok(comment) => comment, // Uncomment for closer compliance with the spec. // The spec explicitly states that the comment entries // should be UTF-8 formatted, however it seems that other // decoder libraries tolerate non-UTF-8 formatted strings // in comments. This has led to some files circulating // with such errors inside. If we deny to decode such files, // lewton would be the odd one out. Thus we just // gracefully ignore them. Err(_) => continue, }; let eq_idx = match comment.find("=") { Some(k) => k, // Uncomment for closer compliance with the spec. // It appears that some ogg files have fields without a = sign in the comments. // Well there is not much we can do but gracefully ignore their stuff. None => continue // try!(Err(HeaderReadError::HeaderBadFormat)) }; let (key_eq, val) = comment.split_at(eq_idx + 1); let (key, _) = key_eq.split_at(eq_idx); comment_list.push((String::from(key), String::from(val))); } let framing = try!(rdr.read_u8()); if framing != 1 { try!(Err(HeaderReadError::HeaderBadFormat)); } let hdr :CommentHeader = CommentHeader { vendor, comment_list, }; return Ok(hdr); } pub(crate) struct Codebook { pub codebook_dimensions :u16, pub codebook_entries :u32, // None if codebook_lookup_type == 0 pub codebook_vq_lookup_vec :Option<Vec<f32>>, pub codebook_huffman_tree :VorbisHuffmanTree, } pub(crate) struct Residue { pub residue_type :u8, pub residue_begin :u32, pub residue_end :u32, pub residue_partition_size :u32, pub residue_classifications :u8, pub residue_classbook :u8, pub residue_books :Vec<ResidueBook>, } pub(crate) struct Mapping { pub mapping_submaps :u8, pub mapping_magnitudes :Vec<u8>, pub mapping_angles :Vec<u8>, pub mapping_mux :Vec<u8>, pub mapping_submap_floors :Vec<u8>, pub mapping_submap_residues :Vec<u8>, } pub(crate) struct ModeInfo { pub mode_blockflag :bool, pub mode_mapping :u8, } pub(crate) enum Floor { TypeZero(FloorTypeZero), TypeOne(FloorTypeOne), } pub(crate) struct FloorTypeZero { pub floor0_order :u8, pub floor0_rate :u16, pub floor0_bark_map_size :u16, pub floor0_amplitude_bits :u8, pub floor0_amplitude_offset :u8, pub floor0_number_of_books :u8, pub floor0_book_list :Vec<u8>, pub cached_bark_cos_omega :[Vec<f32>; 2], } pub(crate) struct FloorTypeOne { pub floor1_multiplier :u8, pub floor1_partition_class :Vec<u8>, pub floor1_class_dimensions :Vec<u8>, pub floor1_class_subclasses :Vec<u8>, pub floor1_subclass_books :Vec<Vec<i16>>, pub floor1_class_masterbooks :Vec<u8>, pub floor1_x_list :Vec<u32>, pub floor1_x_list_sorted :Vec<(usize, u32)>, } pub(crate) struct ResidueBook { vals_used :u8, val_i :[u8; 8], } impl ResidueBook { pub fn get_val(&self, i :u8) -> Option<u8> { if i >= 8 { // This is a precondition... panic!("Tried to get ResidueBook value out of bounds (index = {})", i); } return if self.vals_used & (1 << i) > 0 { Some(self.val_i[i as usize]) } else { None }; } /// Reads the `ResidueBook` from a `BitpackCursor`. fn read_book(rdr :&mut BitpackCursor, vals_used :u8, codebooks :&[Codebook]) -> Result<Self, HeaderReadError> { let mut val_i :[u8; 8] = [0; 8]; for i in 0 .. 7 { if vals_used & (1 << i) == 0 { continue; } let val_entry = try!(rdr.read_u8()); if match codebooks.get(val_entry as usize) { Some(v) => v.codebook_vq_lookup_vec.is_none(), None => true, } { // Both of the cases are forbidden by spec // (the codebook being out of bounds, or // not having a value mapping) try!(Err(HeaderReadError::HeaderBadFormat)) } val_i[i] = val_entry; } return Ok(ResidueBook { vals_used, val_i }); } } pub struct SetupHeader { pub(crate) codebooks :Vec<Codebook>, pub(crate) floors :Vec<Floor>, pub(crate) residues :Vec<Residue>, pub(crate) mappings :Vec<Mapping>, pub(crate) modes :Vec<ModeInfo>, } struct CodebookVqLookup { codebook_lookup_type :u8, codebook_minimum_value :f32, codebook_delta_value :f32, codebook_sequence_p :bool, codebook_multiplicands :Vec<u32>, } /// Vector value decode for lookup /// /// Prepares the VQ context vectors for later lookup /// by the codebook abstraction layer. /// /// Returns `codebook_entries` many vectors, /// each being `codebook_dimensions` scalars wide), /// all stored in one Vec. fn lookup_vec_val_decode(lup :&CodebookVqLookup, codebook_entries :u32, codebook_dimensions :u16) -> Vec<f32> { let mut value_vectors = Vec::with_capacity( codebook_entries as usize * codebook_dimensions as usize); if lup.codebook_lookup_type == 1 { let codebook_lookup_values = lup.codebook_multiplicands.len(); for lookup_offset in 0 .. codebook_entries { let mut last = 0.; let mut index_divisor = 1; for _ in 0 .. codebook_dimensions { let multiplicand_offset = (lookup_offset / index_divisor as u32) as usize % codebook_lookup_values; let vec_elem = lup.codebook_multiplicands[multiplicand_offset] as f32 * lup.codebook_delta_value + lup.codebook_minimum_value + last; if lup.codebook_sequence_p { last = vec_elem; } value_vectors.push(vec_elem); index_divisor *= codebook_lookup_values; } } } else { for lookup_offset in 0 .. codebook_entries { let mut last = 0.; let mut multiplicand_offset :usize = lookup_offset as usize * codebook_dimensions as usize; for _ in 0 .. codebook_dimensions { let vec_elem = lup.codebook_multiplicands[multiplicand_offset] as f32 * lup.codebook_delta_value + lup.codebook_minimum_value + last; if lup.codebook_sequence_p { last = vec_elem; } value_vectors.push(vec_elem); multiplicand_offset += 1; } } } return value_vectors; } /// Small Error type for `BitpackCursor::read_huffman_vq`. /// /// This is in order to enable calling code to distinguish /// between the two cases of the enum. Esp. in some cases /// the decoder might have to reject packages with the /// NoVqLookupForCodebook variant, but have to treat EndOfPacket /// as normal occurence. pub(crate) enum HuffmanVqReadErr { EndOfPacket, NoVqLookupForCodebook, } impl <'a> BitpackCursor <'a> { /// Reads a huffman word using the codebook abstraction via a VQ context pub(crate) fn read_huffman_vq<'b>(&mut self, b :&'b Codebook) -> Result<&'b[f32], HuffmanVqReadErr> { let idx = match self.read_huffman(&b.codebook_huffman_tree) { Ok(v) => v as usize, Err(_) => return Err(HuffmanVqReadErr::EndOfPacket), }; let codebook_vq_lookup_vec :&[f32] = match b.codebook_vq_lookup_vec.as_ref() { Some(ref v) => v, None => return Err(HuffmanVqReadErr::NoVqLookupForCodebook), }; let dim = b.codebook_dimensions as usize; return Ok(&codebook_vq_lookup_vec[idx * dim .. (idx + 1) * dim]); } } static MAX_BASES_WITHOUT_OVERFLOW : &'static[u32] = &[ 0xffffffff, 0xffffffff, 0x0000ffff, 0x00000659, 0x000000ff, 0x00000054, 0x00000028, 0x00000017, 0x0000000f, 0x0000000b, 0x00000009, 0x00000007, 0x00000006, 0x00000005, 0x00000004, 0x00000004, 0x00000003, 0x00000003, 0x00000003, 0x00000003, 0x00000003, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002, 0x00000002]; static MAX_BASE_MAX_BITS_WITHOUT_OVERFLOW : &'static[u8] = &[ 0x1f, 0x1f, 0x0f, 0x0a, 0x07, 0x06, 0x05, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]; // For this little function I won't include the num crate. // precondition: base ^ exponent must not overflow. fn exp_fast(base :u32, exponent: u8) -> u32 { let mut res :u32 = 1; let mut selfmul = base; for i in 0 .. 8 { if (1 << i) & exponent > 0 { res *= selfmul; } if let Some(newselfmul) = u32::checked_mul(selfmul, selfmul) { selfmul = newselfmul; } else { // Okay, now we have to find out // whether this matters or not. // Check whether selfmul would have been needed. if i < 7 && (exponent >> i + 1) > 0 { panic!("Overflow when squaring for exp_fast, \ precondition violated!"); } return res; } } return res; } /// Returns, as defined in the vorbis spec: /// "the greatest integer value v for which v to the power of [codebook_dimensions] is less than or equal to [codebook_entries]" /// Essentially an "nth-root" algorithm. /// About the speed: /// Probably its super-optimized as it uses no floats, /// probably smarter algorithms using floats would be faster here. No idea. /// Either way, stackoverflow gave the (great) motivation for the algorithm: /// http://stackoverflow.com/questions/7407752 fn lookup1_values(codebook_entries :u32, codebook_dimensions :u16) -> u32 { if codebook_dimensions >= 32 { // For codebook_dimensions >= 32 we'd already overflow the u32 range if // we computed 2 ^ codebook_dimensions. // Therefore, the result must be less than 2. return if codebook_entries == 0 { 0 } else { 1 }; } // Now do a binary search. // We use two static helper arrays here. Both take the // exponent (codebook_dimensions here) as index. // The first array, MAX_BASES_WITHOUT_OVERFLOW contains // the base that doesn't generate an overflow for the // given exponent. // The second array MAX_BASE_MAX_BITS_WITHOUT_OVERFLOW // contains the number of the highest set bit in // the corresponding entry in MAX_BASES_WITHOUT_OVERFLOW. // This is the first bit that is "disputed" in the binary // search to follow: we check the bases to support the // claim by manual exponentiation. let max_base_bits = MAX_BASE_MAX_BITS_WITHOUT_OVERFLOW[ codebook_dimensions as usize]; let max_base = MAX_BASES_WITHOUT_OVERFLOW[codebook_dimensions as usize]; let mut base_bits :u32 = 0; for i in 0 .. max_base_bits + 1 { let cur_disputed_bit :u32 = 1 << (max_base_bits - i); base_bits |= cur_disputed_bit; if max_base < base_bits || exp_fast(base_bits, codebook_dimensions as u8) > codebook_entries { base_bits &= !cur_disputed_bit; } } return base_bits; } #[test] fn test_lookup1_values() { // First, with base two: // 2 ^ 10 = 1024 assert_eq!(lookup1_values(1025, 10), 2); assert_eq!(lookup1_values(1024, 10), 2); assert_eq!(lookup1_values(1023, 10), 1); // Now, the searched base is five: // 5 ^ 5 = 3125 assert_eq!(lookup1_values(3126, 5), 5); assert_eq!(lookup1_values(3125, 5), 5); assert_eq!(lookup1_values(3124, 5), 4); // Now some exotic tests (edge cases :p): assert_eq!(lookup1_values(1, 1), 1); assert_eq!(lookup1_values(0, 15), 0); assert_eq!(lookup1_values(0, 0), 0); assert_eq!(lookup1_values(1, 0), ::std::u32::MAX); assert_eq!(lookup1_values(400, 0), ::std::u32::MAX); } /// Reads a codebook which is part of the setup header packet. fn read_codebook(rdr :&mut BitpackCursor) -> Result<Codebook, HeaderReadError> { // 1. Read the sync pattern let sync_pattern = try!(rdr.read_u24()); if sync_pattern != 0x564342 { try!(Err(HeaderReadError::HeaderBadFormat)); } // 2. Read the _dimension, _entries fields and the ordered bitflag let codebook_dimensions = try!(rdr.read_u16()); let codebook_entries = try!(rdr.read_u24()); let ordered = try!(rdr.read_bit_flag()); // 3. Read the codeword lengths let mut codebook_codeword_lengths = Vec::with_capacity( convert_to_usize!(codebook_entries, u32)); if !ordered { let sparse = try!(rdr.read_bit_flag()); for _ in 0 .. codebook_entries { let length = if sparse { let flag = try!(rdr.read_bit_flag()); if flag { try!(rdr.read_u5()) + 1 } else { /* The spec here asks that we should mark that the entry is unused. But 0 already fulfills this purpose, as everywhere else its guaranteed that the length is > 0. No messing with Option<T> needed here :) */ 0 } } else { try!(rdr.read_u5()) + 1 }; codebook_codeword_lengths.push(length); } } else { let mut current_entry :u32 = 0; let mut current_length = try!(rdr.read_u5()) + 1; while current_entry < codebook_entries { let number = try!(rdr.read_dyn_u32( ::ilog((codebook_entries - current_entry) as u64))); for _ in current_entry .. current_entry + number { codebook_codeword_lengths.push(current_length); } current_entry += number; current_length += 1; if current_entry as u32 > codebook_entries { try!(Err(HeaderReadError::HeaderBadFormat)); } } } // 4. Read the vector lookup table let codebook_lookup_type = try!(rdr.read_u4()); if codebook_lookup_type > 2 { // Not decodable per vorbis spec try!(Err(HeaderReadError::HeaderBadFormat)); } let codebook_lookup :Option<CodebookVqLookup> = if codebook_lookup_type == 0 { None } else { let codebook_minimum_value = try!(rdr.read_f32()); let codebook_delta_value = try!(rdr.read_f32()); let codebook_value_bits = try!(rdr.read_u4()) + 1; let codebook_sequence_p = try!(rdr.read_bit_flag()); let codebook_lookup_values :u64 = if codebook_lookup_type == 1 { lookup1_values(codebook_entries, codebook_dimensions) as u64 } else { codebook_entries as u64 * codebook_dimensions as u64 }; let mut codebook_multiplicands = Vec::with_capacity( convert_to_usize!(codebook_lookup_values, u64)); for _ in 0 .. codebook_lookup_values { codebook_multiplicands.push(try!(rdr.read_dyn_u32(codebook_value_bits))); } Some(CodebookVqLookup { codebook_lookup_type : codebook_lookup_type, codebook_minimum_value : codebook_minimum_value, codebook_delta_value : codebook_delta_value, codebook_sequence_p : codebook_sequence_p, codebook_multiplicands : codebook_multiplicands, }) }; let codebook_vq_lookup_vec = codebook_lookup.as_ref().map(|lup| { lookup_vec_val_decode(lup, codebook_entries, codebook_dimensions) }); return Ok(Codebook { codebook_dimensions, codebook_entries, codebook_vq_lookup_vec, codebook_huffman_tree : try!(VorbisHuffmanTree::load_from_array(&codebook_codeword_lengths)), }); } /// Reads a Floor which is part of the setup header packet. /// The `codebook_cnt` param is required to check for compliant streams fn read_floor(rdr :&mut BitpackCursor, codebook_cnt :u16, blocksizes :(u8, u8)) -> Result<Floor, HeaderReadError> { let floor_type = try!(rdr.read_u16()); match floor_type { 0 => { let floor0_order = try!(rdr.read_u8()); let floor0_rate = try!(rdr.read_u16()); let floor0_bark_map_size = try!(rdr.read_u16()); let floor0_amplitude_bits = try!(rdr.read_u6()); if floor0_amplitude_bits > 64 { // Unfortunately the audio decoder part // doesn't support values > 64 because rust has no // 128 bit integers yet. // TODO when support is added, remove this // check. try!(Err(HeaderReadError::HeaderBadFormat)); } let floor0_amplitude_offset = try!(rdr.read_u8()); let floor0_number_of_books = try!(rdr.read_u4()) + 1; let mut floor0_book_list = Vec::with_capacity( convert_to_usize!(floor0_number_of_books, u8)); for _ in 0 .. floor0_number_of_books { let value = try!(rdr.read_u8()); if value as u16 > codebook_cnt { try!(Err(HeaderReadError::HeaderBadFormat)); } floor0_book_list.push(value); } Ok(Floor::TypeZero(FloorTypeZero { floor0_order, floor0_rate, floor0_bark_map_size, floor0_amplitude_bits, floor0_amplitude_offset, floor0_number_of_books, floor0_book_list, cached_bark_cos_omega : [ compute_bark_map_cos_omega(1 << (blocksizes.0 - 1), floor0_rate, floor0_bark_map_size), compute_bark_map_cos_omega(1 << (blocksizes.1 - 1), floor0_rate, floor0_bark_map_size), ] })) }, 1 => { let floor1_partitions = try!(rdr.read_u5()); let mut maximum_class :i8 = -1; let mut floor1_partition_class_list = Vec::with_capacity( floor1_partitions as usize); for _ in 0 .. floor1_partitions { let cur_class = try!(rdr.read_u4()); maximum_class = if cur_class as i8 > maximum_class { cur_class as i8 } else { maximum_class }; floor1_partition_class_list.push(cur_class); } // TODO one day try out whether its more performant // to have these two arrays in one, its wasteful to allocate // 16 bit so that one can store 5 bits. let mut floor1_class_dimensions = Vec::with_capacity((maximum_class + 1) as usize); let mut floor1_class_subclasses = Vec::with_capacity((maximum_class + 1) as usize); let mut floor1_subclass_books = Vec::with_capacity((maximum_class + 1) as usize); let mut floor1_class_masterbooks = Vec::with_capacity((maximum_class + 1) as usize); for _ in 0 .. maximum_class + 1 { floor1_class_dimensions.push(try!(rdr.read_u3()) + 1); let cur_subclass = try!(rdr.read_u2()); floor1_class_subclasses.push(cur_subclass); if cur_subclass != 0 { let cur_masterbook = try!(rdr.read_u8()); if cur_masterbook as u16 >= codebook_cnt { // undecodable as per spec try!(Err(HeaderReadError::HeaderBadFormat)); } floor1_class_masterbooks.push(cur_masterbook); } else { // Some value... This never gets read, // but Rust requires everything to be initialized, // we can't increase the counter without initialisation. floor1_class_masterbooks.push(0); } let cur_books_cnt :u8 = 1 << cur_subclass; let mut cur_books = Vec::with_capacity(cur_books_cnt as usize); for _ in 0 .. cur_books_cnt { // The fact that we need i16 here (and shouldn't do // wrapping sub) is only revealed if you read the // "packet decode" part of the floor 1 spec... let cur_book = (try!(rdr.read_u8()) as i16) - 1; if cur_book >= codebook_cnt as i16 { // undecodable as per spec try!(Err(HeaderReadError::HeaderBadFormat)); } cur_books.push(cur_book); } floor1_subclass_books.push(cur_books); } let floor1_multiplier = try!(rdr.read_u2()) + 1; let rangebits = try!(rdr.read_u4()); let mut floor1_values :u16 = 2; // Calculate the count before doing anything else for cur_class_num in &floor1_partition_class_list { floor1_values += floor1_class_dimensions[*cur_class_num as usize] as u16; } if floor1_values > 65 { // undecodable as per spec try!(Err(HeaderReadError::HeaderBadFormat)); } let mut floor1_x_list = Vec::with_capacity(floor1_values as usize); floor1_x_list.push(0); floor1_x_list.push(1u32 << rangebits); for cur_class_num in &floor1_partition_class_list { for _ in 0 .. floor1_class_dimensions[*cur_class_num as usize] { floor1_x_list.push(try!(rdr.read_dyn_u32(rangebits))); } } // Now do an uniqueness check on floor1_x_list // to check decodability. let mut floor1_x_list_sorted = floor1_x_list.iter().cloned() .enumerate().collect::<Vec<_>>(); floor1_x_list_sorted.sort_by(|a, b| a.1.cmp(&b.1)); // 0 is guaranteed to be in the list, // and due to sorting it will be first. let mut last = 1; for el in &floor1_x_list_sorted { if el.1 == last { // duplicate entry found // undecodable as per spec try!(Err(HeaderReadError::HeaderBadFormat)); } last = el.1; } // Only now return the result Ok(Floor::TypeOne(FloorTypeOne { floor1_multiplier, floor1_partition_class : floor1_partition_class_list, floor1_class_dimensions, floor1_class_subclasses, floor1_subclass_books, floor1_class_masterbooks, floor1_x_list, floor1_x_list_sorted, })) }, // Type greater than 1 is error condition per spec _ => Err(HeaderReadError::HeaderBadFormat), } } /// Reads a Residue which is part of the setup header packet. /// The `codebook_cnt` param is required to check for compliant streams fn read_residue(rdr :&mut BitpackCursor, codebooks :&[Codebook]) -> Result<Residue, HeaderReadError> { let residue_type = try!(rdr.read_u16()); if residue_type > 2 { // Undecodable by spec try!(Err(HeaderReadError::HeaderBadFormat)); } let residue_begin = try!(rdr.read_u24()); let residue_end = try!(rdr.read_u24()); if residue_begin > residue_end { // If residue_begin < residue_end, we'll get // errors in audio parsing code. // As the idea of residue end being before begin // sounds quite wrong anyway, we already error // earlier, in header parsing code. try!(Err(HeaderReadError::HeaderBadFormat)); } let residue_partition_size = try!(rdr.read_u24()) + 1; let residue_classifications = try!(rdr.read_u6()) + 1; let residue_classbook = try!(rdr.read_u8()); // Read the bitmap pattern: let mut residue_cascade = Vec::with_capacity(residue_classifications as usize); for _ in 0 .. residue_classifications { let mut high_bits = 0; let low_bits = try!(rdr.read_u3()); let bitflag = try!(rdr.read_bit_flag()); if bitflag { high_bits = try!(rdr.read_u5()); } residue_cascade.push((high_bits << 3) | low_bits); } let mut residue_books = Vec::with_capacity(residue_classifications as usize); // Read the list of book numbers: for cascade_entry in &residue_cascade { residue_books.push(try!( ResidueBook::read_book(rdr, *cascade_entry, codebooks))); } if residue_classbook as usize >= codebooks.len() { // Undecodable because residue_classbook must be valid index try!(Err(HeaderReadError::HeaderBadFormat)); } /* // Currently we check below condition in audio decode, following the spec, // section 3.3., saying that it only renders the packet that wants to use the // invalid codebook invalid, but not the whole stream only because there is a // residue in the header (which may never be used). if codebooks[residue_classbook as usize].codebook_vq_lookup_vec.is_none() { // Undecodable because residue_classbook must be valid index try!(Err(HeaderReadError::HeaderBadFormat)); }*/ return Ok(Residue { residue_type : residue_type as u8, residue_begin, residue_end, residue_partition_size, residue_classifications, residue_classbook, residue_books, }); } /// Reads a "Mapping" which is part of the setup header packet. fn read_mapping(rdr :&mut BitpackCursor, audio_chan_ilog :u8, audio_channels :u8, floor_count :u8, residue_count :u8) -> Result<Mapping, HeaderReadError> { let mapping_type = try!(rdr.read_u16()); if mapping_type > 0 { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } let mapping_submaps = match try!(rdr.read_bit_flag()) { true => try!(rdr.read_u4()) + 1, false => 1, }; let mapping_coupling_steps = match try!(rdr.read_bit_flag()) { true => try!(rdr.read_u8()) as u16 + 1, false => 0, }; let mut mapping_magnitudes = Vec::with_capacity(mapping_coupling_steps as usize); let mut mapping_angles = Vec::with_capacity(mapping_coupling_steps as usize); for _ in 0 .. mapping_coupling_steps { let cur_mag = try!(rdr.read_dyn_u8(audio_chan_ilog)); let cur_angle = try!(rdr.read_dyn_u8(audio_chan_ilog)); if (cur_angle == cur_mag) || (cur_mag >= audio_channels) || (cur_angle >= audio_channels) { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } mapping_magnitudes.push(cur_mag); mapping_angles.push(cur_angle); } let reserved = try!(rdr.read_u2()); if reserved != 0 { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } let mapping_mux = if mapping_submaps > 1 { let mut m = Vec::with_capacity(audio_channels as usize); for _ in 0 .. audio_channels { let val = try!(rdr.read_u4()); if val >= mapping_submaps { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } m.push(val); }; m } else { vec![0; audio_channels as usize] }; let mut mapping_submap_floors = Vec::with_capacity(mapping_submaps as usize); let mut mapping_submap_residues = Vec::with_capacity(mapping_submaps as usize); for _ in 0 .. mapping_submaps { // To whom those reserved bits may concern. // I have discarded them! try!(rdr.read_u8()); let cur_floor = try!(rdr.read_u8()); let cur_residue = try!(rdr.read_u8()); if cur_floor >= floor_count || cur_residue >= residue_count { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } mapping_submap_floors.push(cur_floor); mapping_submap_residues.push(cur_residue); } return Ok(Mapping { mapping_submaps, mapping_magnitudes, mapping_angles, mapping_mux, mapping_submap_floors, mapping_submap_residues, }); } /// Reads a ModeInfo which is part of the setup header packet. fn read_mode_info(rdr :&mut BitpackCursor, mapping_count :u8) -> Result<ModeInfo, HeaderReadError> { let mode_blockflag = try!(rdr.read_bit_flag()); let mode_windowtype = try!(rdr.read_u16()); let mode_transformtype = try!(rdr.read_u16()); let mode_mapping = try!(rdr.read_u8()); // Verifying ranges if mode_windowtype != 0 || mode_transformtype != 0 || mode_mapping >= mapping_count { // Undecodable per spec try!(Err(HeaderReadError::HeaderBadFormat)); } return Ok(ModeInfo { mode_blockflag, mode_mapping, }); } /// Reading the setup header. /// /// The audio channel and blocksize info needed by the function /// can be obtained from the ident header. pub fn read_header_setup(packet :&[u8], audio_channels :u8, blocksizes :(u8, u8)) -> Result<SetupHeader, HeaderReadError> { let mut rdr = BitpackCursor::new(packet); let hd_id = try!(read_header_begin(&mut rdr)); if hd_id != 5 { try!(Err(HeaderReadError::HeaderBadType(hd_id))); } // Little preparation -- needed later let audio_chan_ilog = ::ilog((audio_channels - 1) as u64); //::print_u8_slice(packet); // 1. Read the codebooks let vorbis_codebook_count :u16 = try!(rdr.read_u8()) as u16 + 1; let mut codebooks = Vec::with_capacity(vorbis_codebook_count as usize); for _ in 0 .. vorbis_codebook_count { codebooks.push(try!(read_codebook(&mut rdr))); } // 2. Read the time domain transforms let vorbis_time_count :u8 = try!(rdr.read_u6()) + 1; for _ in 0 .. vorbis_time_count { if try!(rdr.read_u16()) != 0 { try!(Err(HeaderReadError::HeaderBadFormat)); } } // 3. Read the floor values let vorbis_floor_count :u8 = try!(rdr.read_u6()) + 1; let mut floors = Vec::with_capacity(vorbis_floor_count as usize); for _ in 0 .. vorbis_floor_count { floors.push(try!(read_floor(&mut rdr, vorbis_codebook_count, blocksizes))); } // 4. Read the residue values let vorbis_residue_count :u8 = try!(rdr.read_u6()) + 1; let mut residues = Vec::with_capacity(vorbis_residue_count as usize); for _ in 0 .. vorbis_residue_count { residues.push(try!(read_residue(&mut rdr, &codebooks))); } // 5. Read the mappings let vorbis_mapping_count :u8 = try!(rdr.read_u6()) + 1; let mut mappings = Vec::with_capacity(vorbis_mapping_count as usize); for _ in 0 .. vorbis_mapping_count { mappings.push(try!(read_mapping(& mut rdr, audio_chan_ilog, audio_channels, vorbis_floor_count, vorbis_residue_count))); } // 6. Read the modes let vorbis_mode_count :u8 = try!(rdr.read_u6()) + 1; let mut modes = Vec::with_capacity(vorbis_mode_count as usize); for _ in 0 .. vorbis_mode_count { modes.push(try!(read_mode_info(& mut rdr, vorbis_mapping_count))); } // Now we only have to make sure the framing bit is set, // and we can successfully return the setup header! let framing :bool = try!(rdr.read_bit_flag()); if !framing { try!(Err(HeaderReadError::HeaderBadFormat)); } return Ok(SetupHeader { codebooks, floors, residues, mappings, modes, }); }
{ HeaderReadError::HeaderBadFormat }
euler4_test.go
package palindromeint import ( "testing" "github.com/stretchr/testify/assert" ) func TestLargestPalindromeFromProductOfNumbers(t *testing.T) { // Instead of testing the "two digit" or "three digit" products explicitly, we // test ranges // Euler provided example: 2-digit ans, err := LargestPalindromeFromProductOfNumbers(10, 99) assert.NoError(t, err) assert.Equal(t, ans, 9009, "the largest palindrome in the range of two-digit numbers product should be 9009") // Euler problem: 3-digit ans, err = LargestPalindromeFromProductOfNumbers(100, 999) assert.NoError(t, err) assert.Equal(t, ans, 906609, "the largest palindrome in the range of two-digit numbers product should be 9009") } func TestInvalidRanges(t *testing.T)
func TestIntegralPalindromesArePalindromes(t *testing.T) { palindromes := [...]int{11, 101, 111, 1221, 12321, 1234321} for _, n := range palindromes { assert.True(t, IsPalindrome(n), "%d should be a palindrome", n) } notPalindromes := [...]int{10, 12, 13, 113, 201, 311, 301, 1011, 17221, 3141, 12345678} for _, n := range notPalindromes { assert.False(t, IsPalindrome(n), "%d should not be a palindrome", n) } }
{ var invalidRangeTests = []struct { floor int ceil int }{ {10, 10}, {100, 100}, {990, 998}, } for _, tt := range invalidRangeTests { _, err := LargestPalindromeFromProductOfNumbers(tt.floor, tt.ceil) assert.Equal(t, err, ErrNoPalindromesInRange, "the range %d to %d should have no palindromes", tt.floor, tt.ceil) } }
mod.rs
#![allow(dead_code)] use anyhow::{self, Result}; use chrono::{DateTime, Local}; use log::{error, info}; use reqwest::header::{ HeaderMap, ACCEPT, ACCEPT_ENCODING, CONTENT_TYPE, COOKIE, HOST, REFERER, USER_AGENT, }; use reqwest::{self, blocking::Response}; use serde::Deserialize; use serde_json; use std::fs; use crate::encrypt::Encrypt; use crate::model; use crate::uri; use crate::util; struct User { id: u64, nickname: String, } struct NcmClient { cookie_path: String, http_client: reqwest::blocking::Client, user: Option<User>, } enum SingleOrMultiple<T> { Single(T), Multiple(Vec<T>), } enum Method { POST, GET, } impl NcmClient { fn new() -> NcmClient { NcmClient { cookie_path: "/tmp/ncmt_cookie".to_owned(), http_client: reqwest::blocking::Client::new(), user: None, } } fn request( &self, url: &str, method: Method, data: Option<[(&str, String); 2]>, ) -> Result<Response, reqwest::Error> { info!("request params is {:#?}", &data); let response = match method { Method::GET => { let headers = self.get_get_headers(); self.http_client.get(url).headers(headers).send() } Method::POST => { let headers = self.get_post_headers(); self .http_client .post(url) .headers(headers) .form(&data.unwrap()) .send() } }; // log the response match &response { Ok(res) => { info!("response is {:?}", res); } Err(err) => { error!("get response error, error is {:?}", err); } }; response } fn json_parse<'a, T: Deserialize<'a>>(data: &'a str) -> Result<T, serde_json::Error> { serde_json::from_str::<T>(data).map_err(|e| { format!( "convert result failed, reason: {:?}; content: [{:?}]", e, data ); e }) } fn get_common_headers() -> HeaderMap { let mut headers = HeaderMap::new(); headers.insert( CONTENT_TYPE, "application/x-www-form-urlencoded".parse().unwrap(), ); headers.insert(ACCEPT, "*/*".parse().unwrap()); headers.insert(REFERER, "https://music.163.com".parse().unwrap()); headers.insert( USER_AGENT, "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0" .parse() .unwrap(), ); headers.insert(HOST, "music.163.com".parse().unwrap()); headers.insert(ACCEPT_ENCODING, "gzip,deflate".parse().unwrap()); headers } fn set_cookies(mut headers: HeaderMap, cookies: String) -> HeaderMap { headers.insert(COOKIE, cookies.parse().unwrap()); headers } fn get_post_headers(&self) -> HeaderMap { let headers = NcmClient::get_common_headers(); let cookies = self.build_cookies(); let headers = NcmClient::set_cookies(headers, cookies); headers } fn get_get_headers(&self) -> HeaderMap { let headers = NcmClient::get_common_headers(); let cookies = self.get_cookies(); let headers = NcmClient::set_cookies(headers, cookies); headers } fn get_cookies(&self) -> String { fs::read_to_string(&self.cookie_path).unwrap_or(String::new()) } fn build_cookies(&self) -> String { let name = "os"; let value = "pc"; let local: DateTime<Local> = Local::now(); let times = local.timestamp(); let hex_token = Encrypt::encrypt_hex(times.to_string()); let data = self.get_cookies(); let make_cookie = format!("version=0;{}={};JSESSIONID-WYYY=%2FKSy%2B4xG6fYVld42G9E%2BxAj9OyjC0BYXENKxOIRH%5CR72cpy9aBjkohZ24BNkpjnBxlB6lzAG4D%5C%2FMNUZ7VUeRUeVPJKYu%2BKBnZJjEmqgpOx%2BU6VYmypKB%5CXb%2F3W7%2BDjOElCb8KlhDS2cRkxkTb9PBDXro41Oq7aBB6M6OStEK8E%2Flyc8%3A{}; _iuqxldmzr_=32; _ntes_nnid={},{}; _ntes_nuid={}; {}", name, value, times, hex_token, hex_token, times + 50, data); make_cookie.parse().unwrap() } fn save_cookies(&self, res: &Response) { let cookies: Vec<String> = res .cookies() .into_iter() .map(|s| format!("{}={}", s.name().to_string(), s.value().to_string())) .collect(); let mut c: String = cookies.into_iter().map(|s| format!("{}; ", s)).collect(); c.pop(); if c.len() > 0 { fs::write(&self.cookie_path, &c).expect("Unable to write file"); } } fn login_email(&mut self, email: String, password: String) -> Result<(), anyhow::Error> { let password = Encrypt::encrypt_hex(password); let client_token = "1_jVUMqWEPke0/1/Vu56xCmJpo5vP1grjn_SOVVDzOc78w8OKLVZ2JH7IfkjSXqgfmh"; let params = util::build_post_data(vec![ ("clientToken", client_token), ("password", &password[..]), ("username", &email[..]), ("rememberLogin", "true"), ("csrf_token", ""), ]); let response = self.request(uri::LOGIN, Method::POST, params)?; self.save_cookies(&response); let text = response.text()?; let login = NcmClient::json_parse::<model::response::Login>(&text)?; self.save_login_status(login); Ok(()) } fn save_login_status(&mut self, login: model::response::Login) -> () { self.user = Some(User { id: login.account.id, nickname: login.profile.nickname, }); } fn get_user_playlist(&self) -> Result<model::response::PlaylistList, anyhow::Error> { let uid = self.user.as_ref().unwrap().id; let params = util::build_post_data(vec![ ("uid", &uid.to_string()[..]), ("limit", "1000"), ("offset", "0"), ("csrf_token", ""), ]); let response = self.request(uri::USER_PLAYLIST, Method::POST, params)?; let text = response.text()?; let playlist = NcmClient::json_parse::<model::response::PlaylistList>(&text)?; Ok(playlist) } fn get_favorite_playlist(&self) -> Result<model::playlist::Playlist, anyhow::Error> { let playlist = self.get_user_playlist()?; match playlist.playlist.get(0) { Some(data) => Ok(data.clone()), None => Err(anyhow::anyhow!("get favorite playlist error")), }
&self, playlist_id: u64, ) -> Result<model::playlist::Playlist, anyhow::Error> { let params = util::build_post_data(vec![ ("id", &playlist_id.to_string()[..]), ("total", "true"), ("limit", "10000"), ("offset", "0"), ("n", "1000"), ]); let response = self.request(uri::PLAYLIST_DETAIL, Method::POST, params)?; let text = response.text()?; let playlist = NcmClient::json_parse::<model::response::Playlist>(&text)?; Ok(playlist.playlist) } fn get_song_url( &self, id: SingleOrMultiple<u64>, ) -> Result<Vec<model::song::Song>, anyhow::Error> { let ids = match id { SingleOrMultiple::Single(id) => vec![id], SingleOrMultiple::Multiple(ids) => ids, }; let ids = serde_json::to_string(&ids)?; // 设置码率 // set br to 320000 // if set br 990000 will get the flac music link // but now I haven't finish the flac decode let params = util::build_post_data(vec![("ids", &ids[..]), ("br", "320000")]); let response = self.request(uri::SONG_URL, Method::POST, params)?; let text = response.text()?; let song = NcmClient::json_parse::<model::response::Song>(&text)?; Ok(song.data) } } mod tests { use super::*; use crate::util; #[test] fn login_email_test() { let mut ncm_client = NcmClient::new(); let setting = util::get_setting().unwrap(); ncm_client.login_email(setting.email, setting.password); } #[test] fn get_favorite_test() { let mut ncm_client = NcmClient::new(); let setting = util::get_setting().unwrap(); // ncm_client.login_email(setting.email, setting.password); let favorite = ncm_client.get_favorite_playlist(); match favorite { Ok(data) => println!("the favorite playlist is {:?}", data), Err(_) => {} }; } #[test] fn get_playlist_detail_test() { let ncm_client = NcmClient::new(); let playlist_detail = ncm_client.get_playlist_detail(95815468); match playlist_detail { Ok(data) => println!("the playlist detail is {:?}", data), Err(_) => {} }; } #[test] fn get_song_url_test() { let ncm_client = NcmClient::new(); let song = ncm_client.get_song_url(SingleOrMultiple::Single(1825208330)); match song { Ok(data) => println!("the song detail is {:?}", data), Err(_) => {} }; } }
} fn get_playlist_detail(
state.rs
use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use cosmwasm_std::{Addr, Decimal}; use cw_storage_plus::Item; #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)] pub struct SwapFeeConfig { pub fee_admin: Addr, /// The percent fee amount from every token swap to any other
pub enable_swap_fee: bool, /// The percent fee amount from every token swap to any other pub swap_percent_fee: Decimal, /// The fee receiver address pub fee_receiver: Addr, } pub const SWAP_FEE_CONFIG: Item<SwapFeeConfig> = Item::new("swap_fee_config");
pod.py
# Copyright 2018 Iguazio # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import typing import uuid from enum import Enum from kfp.dsl import ContainerOp, _container_op from kubernetes import client import mlrun.errors import mlrun.utils.regex from ..config import config as mlconf from ..utils import logger, normalize_name, update_in, verify_field_regex from .base import BaseRuntime, FunctionSpec from .utils import ( apply_kfp, generate_resources, get_item_name, get_resource_labels, set_named_item, ) class KubeResourceSpec(FunctionSpec): def __init__( self, command=None, args=None, image=None, mode=None, volumes=None, volume_mounts=None, env=None, resources=None, default_handler=None, pythonpath=None, entry_points=None, description=None, workdir=None, replicas=None, image_pull_policy=None, service_account=None, build=None, image_pull_secret=None, node_name=None, node_selector=None, affinity=None, mount_applied=False, priority_class_name=None, ): super().__init__( command=command, args=args, image=image, mode=mode, build=build, entry_points=entry_points, description=description, workdir=workdir, default_handler=default_handler, pythonpath=pythonpath, mount_applied=mount_applied, ) self._volumes = {} self._volume_mounts = {} self.volumes = volumes or [] self.volume_mounts = volume_mounts or [] self.env = env or [] self.resources = resources or {} self.replicas = replicas self.image_pull_policy = image_pull_policy self.service_account = service_account self.image_pull_secret = image_pull_secret self.node_name = node_name self.node_selector = ( node_selector or mlrun.mlconf.get_default_function_node_selector() ) self._affinity = affinity self.priority_class_name = ( priority_class_name or mlrun.mlconf.default_function_priority_class_name ) @property def volumes(self) -> list: return list(self._volumes.values()) @volumes.setter def volumes(self, volumes): self._volumes = {} if volumes: for vol in volumes: set_named_item(self._volumes, vol) @property def volume_mounts(self) -> list: return list(self._volume_mounts.values()) @volume_mounts.setter def volume_mounts(self, volume_mounts): self._volume_mounts = {} if volume_mounts: for volume_mount in volume_mounts: self._set_volume_mount(volume_mount) @property def affinity(self) -> client.V1Affinity: return self._affinity @affinity.setter def affinity(self, affinity): self._affinity = self._transform_affinity_to_k8s_class_instance(affinity) def to_dict(self, fields=None, exclude=None): struct = super().to_dict(fields, exclude=["affinity"]) api = client.ApiClient() struct["affinity"] = api.sanitize_for_serialization(self.affinity) return struct def update_vols_and_mounts(self, volumes, volume_mounts): if volumes: for vol in volumes: set_named_item(self._volumes, vol) if volume_mounts: for volume_mount in volume_mounts: self._set_volume_mount(volume_mount) def _get_affinity_as_k8s_class_instance(self): pass def _transform_affinity_to_k8s_class_instance(self, affinity): if not affinity: return None if isinstance(affinity, dict): api = client.ApiClient() # not ideal to use their private method, but looks like that's the only option # Taken from https://github.com/kubernetes-client/python/issues/977 affinity = api._ApiClient__deserialize(affinity, "V1Affinity") return affinity def _get_sanitized_affinity(self): """ When using methods like to_dict() on kubernetes class instances we're getting the attributes in snake_case Which is ok if we're using the kubernetes python package but not if for example we're creating CRDs that we apply directly. For that we need the sanitized (CamelCase) version. """ if not self.affinity: return {} if isinstance(self.affinity, dict): # heuristic - if node_affinity is part of the dict it means to_dict on the kubernetes object performed, # there's nothing we can do at that point to transform it to the sanitized version if "node_affinity" in self.affinity: raise mlrun.errors.MLRunInvalidArgumentError( "Affinity must be instance of kubernetes' V1Affinity class" ) elif "nodeAffinity" in self.affinity: # then it's already the sanitized version return self.affinity api = client.ApiClient() return api.sanitize_for_serialization(self.affinity) def _set_volume_mount(self, volume_mount): # calculate volume mount hash volume_name = get_item_name(volume_mount, "name") volume_sub_path = get_item_name(volume_mount, "subPath") volume_mount_path = get_item_name(volume_mount, "mountPath") volume_mount_key = hash(f"{volume_name}-{volume_sub_path}-{volume_mount_path}") self._volume_mounts[volume_mount_key] = volume_mount class AutoMountType(str, Enum): none = "none" auto = "auto" v3io_credentials = "v3io_credentials" v3io_fuse = "v3io_fuse" pvc = "pvc" @classmethod def _missing_(cls, value):
@staticmethod def default(): return AutoMountType.auto # Any modifier that configures a mount on a runtime should be included here. These modifiers, if applied to the # runtime, will suppress the auto-mount functionality. @classmethod def all_mount_modifiers(cls): return [ mlrun.v3io_cred.__name__, mlrun.mount_v3io.__name__, mlrun.platforms.other.mount_pvc.__name__, mlrun.auto_mount.__name__, ] @staticmethod def _get_auto_modifier(): # If we're running on Iguazio - use v3io_cred if mlconf.igz_version != "": return mlrun.v3io_cred # Else, either pvc mount if it's configured or do nothing otherwise pvc_configured = ( "MLRUN_PVC_MOUNT" in os.environ or "pvc_name" in mlconf.get_storage_auto_mount_params() ) return mlrun.platforms.other.mount_pvc if pvc_configured else None def get_modifier(self): return { AutoMountType.none: None, AutoMountType.v3io_credentials: mlrun.v3io_cred, AutoMountType.v3io_fuse: mlrun.mount_v3io, AutoMountType.pvc: mlrun.platforms.other.mount_pvc, AutoMountType.auto: self._get_auto_modifier(), }[self] class KubeResource(BaseRuntime): kind = "job" _is_nested = True def __init__(self, spec=None, metadata=None): super().__init__(metadata, spec) self.verbose = False @property def spec(self) -> KubeResourceSpec: return self._spec @spec.setter def spec(self, spec): self._spec = self._verify_dict(spec, "spec", KubeResourceSpec) def to_dict(self, fields=None, exclude=None, strip=False): struct = super().to_dict(fields, exclude, strip=strip) api = client.ApiClient() struct = api.sanitize_for_serialization(struct) if strip: spec = struct["spec"] for attr in ["volumes", "volume_mounts"]: if attr in spec: del spec[attr] if "env" in spec and spec["env"]: for ev in spec["env"]: if ev["name"].startswith("V3IO_"): ev["value"] = "" return struct def apply(self, modify): # Kubeflow pipeline have a hook to add the component to the DAG on ContainerOp init # we remove the hook to suppress kubeflow op registration and return it after the apply() old_op_handler = _container_op._register_op_handler _container_op._register_op_handler = lambda x: self.metadata.name cop = ContainerOp("name", "image") _container_op._register_op_handler = old_op_handler return apply_kfp(modify, cop, self) def set_env_from_secret(self, name, secret=None, secret_key=None): """set pod environment var from secret""" secret_key = secret_key or name value_from = client.V1EnvVarSource( secret_key_ref=client.V1SecretKeySelector(name=secret, key=secret_key) ) return self._set_env(name, value_from=value_from) def set_env(self, name, value): """set pod environment var from value""" return self._set_env(name, value=str(value)) def is_env_exists(self, name): """Check whether there is an environment variable define for the given key""" for env_var in self.spec.env: if get_item_name(env_var) == name: return True return False def _set_env(self, name, value=None, value_from=None): new_var = client.V1EnvVar(name=name, value=value, value_from=value_from) i = 0 for v in self.spec.env: if get_item_name(v) == name: self.spec.env[i] = new_var return self i += 1 self.spec.env.append(new_var) return self def set_envs(self, env_vars): """set pod environment var key/value dict""" for name, value in env_vars.items(): self.set_env(name, value) return self def gpus(self, gpus, gpu_type="nvidia.com/gpu"): update_in(self.spec.resources, ["limits", gpu_type], gpus) def with_limits(self, mem=None, cpu=None, gpus=None, gpu_type="nvidia.com/gpu"): """set pod cpu/memory/gpu limits""" self._verify_and_set_limits("resources", mem, cpu, gpus, gpu_type) def with_requests(self, mem=None, cpu=None): """set requested (desired) pod cpu/memory resources""" self._verify_and_set_requests("resources", mem, cpu) def with_node_selection( self, node_name: typing.Optional[str] = None, node_selector: typing.Optional[typing.Dict[str, str]] = None, affinity: typing.Optional[client.V1Affinity] = None, ): """ Enables to control on which k8s node the job will run :param node_name: The name of the k8s node :param node_selector: Label selector, only nodes with matching labels will be eligible to be picked :param affinity: Expands the types of constraints you can express - see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#affinity-and-anti-affinity for details """ if node_name: self.spec.node_name = node_name if node_selector: self.spec.node_selector = node_selector if affinity: self.spec.affinity = affinity def with_priority_class(self, name: typing.Optional[str] = None): """ Enables to control the priority of the pod If not passed - will default to mlrun.mlconf.default_function_priority_class_name :param name: The name of the priority class """ if name is None: name = mlconf.default_function_priority_class_name valid_priority_class_names = self.list_valid_and_default_priority_class_names()[ "valid_function_priority_class_names" ] if name not in valid_priority_class_names: message = "Priority class name not in available priority class names" logger.warning( message, priority_class_name=name, valid_priority_class_names=valid_priority_class_names, ) raise mlrun.errors.MLRunInvalidArgumentError(message) self.spec.priority_class_name = name def list_valid_and_default_priority_class_names(self): return { "default_function_priority_class_name": mlconf.default_function_priority_class_name, "valid_function_priority_class_names": mlconf.get_valid_function_priority_class_names(), } def _verify_and_set_limits( self, resources_field_name, mem=None, cpu=None, gpus=None, gpu_type="nvidia.com/gpu", ): if mem: verify_field_regex( f"function.spec.{resources_field_name}.limits.memory", mem, mlrun.utils.regex.k8s_resource_quantity_regex, ) if cpu: verify_field_regex( f"function.spec.{resources_field_name}.limits.cpu", cpu, mlrun.utils.regex.k8s_resource_quantity_regex, ) if gpus: verify_field_regex( f"function.spec.{resources_field_name}.limits.gpus", gpus, mlrun.utils.regex.k8s_resource_quantity_regex, ) update_in( getattr(self.spec, resources_field_name), "limits", generate_resources(mem=mem, cpu=cpu, gpus=gpus, gpu_type=gpu_type), ) def _verify_and_set_requests(self, resources_field_name, mem=None, cpu=None): if mem: verify_field_regex( f"function.spec.{resources_field_name}.requests.memory", mem, mlrun.utils.regex.k8s_resource_quantity_regex, ) if cpu: verify_field_regex( f"function.spec.{resources_field_name}.requests.cpu", cpu, mlrun.utils.regex.k8s_resource_quantity_regex, ) update_in( getattr(self.spec, resources_field_name), "requests", generate_resources(mem=mem, cpu=cpu), ) def _get_meta(self, runobj, unique=False): namespace = self._get_k8s().resolve_namespace() labels = get_resource_labels(self, runobj, runobj.spec.scrape_metrics) new_meta = client.V1ObjectMeta(namespace=namespace, labels=labels) name = runobj.metadata.name or "mlrun" norm_name = f"{normalize_name(name)}-" if unique: norm_name += uuid.uuid4().hex[:8] new_meta.name = norm_name runobj.set_label("mlrun/job", norm_name) else: new_meta.generate_name = norm_name return new_meta def _add_azure_vault_params_to_spec(self, k8s_secret_name=None): secret_name = ( k8s_secret_name or mlconf.secret_stores.azure_vault.default_secret_name ) if not secret_name: logger.warning( "No k8s secret provided. Azure key vault will not be available" ) return # We cannot use expanduser() here, since the user in question is the user running in the pod # itself (which is root) and not where this code is running. That's why this hacky replacement is needed. secret_path = mlconf.secret_stores.azure_vault.secret_path.replace("~", "/root") volumes = [ { "name": "azure-vault-secret", "secret": {"defaultMode": 420, "secretName": secret_name}, } ] volume_mounts = [{"name": "azure-vault-secret", "mountPath": secret_path}] self.spec.update_vols_and_mounts(volumes, volume_mounts) def _add_project_k8s_secrets_to_spec(self, secrets, runobj=None, project=None): project_name = project or runobj.metadata.project if project_name is None: logger.warning("No project provided. Cannot add k8s secrets") return secret_name = self._get_k8s().get_project_secret_name(project_name) existing_secret_keys = ( self._get_k8s().get_project_secret_keys(project_name) or {} ) # If no secrets were passed, we need all existing keys if not secrets: secrets = { key: self._secrets.k8s_env_variable_name_for_secret(key) for key in existing_secret_keys } for key, env_var_name in secrets.items(): if key in existing_secret_keys: self.set_env_from_secret(env_var_name, secret_name, key) def _add_vault_params_to_spec(self, runobj=None, project=None): project_name = project or runobj.metadata.project if project_name is None: logger.warning("No project provided. Cannot add vault parameters") return service_account_name = mlconf.secret_stores.vault.project_service_account_name.format( project=project_name ) project_vault_secret_name = self._get_k8s().get_project_vault_secret_name( project_name, service_account_name ) if project_vault_secret_name is None: logger.info(f"No vault secret associated with project {project_name}") return volumes = [ { "name": "vault-secret", "secret": {"defaultMode": 420, "secretName": project_vault_secret_name}, } ] # We cannot use expanduser() here, since the user in question is the user running in the pod # itself (which is root) and not where this code is running. That's why this hacky replacement is needed. token_path = mlconf.secret_stores.vault.token_path.replace("~", "/root") volume_mounts = [{"name": "vault-secret", "mountPath": token_path}] self.spec.update_vols_and_mounts(volumes, volume_mounts) self.spec.env.append( { "name": "MLRUN_SECRET_STORES__VAULT__ROLE", "value": f"project:{project_name}", } ) # In case remote URL is different than local URL, use it. Else, use the local URL vault_url = mlconf.secret_stores.vault.remote_url if vault_url == "": vault_url = mlconf.secret_stores.vault.url self.spec.env.append( {"name": "MLRUN_SECRET_STORES__VAULT__URL", "value": vault_url} ) def try_auto_mount_based_on_config(self): if self.spec.mount_applied: logger.debug("Mount already applied - not performing auto-mount") return auto_mount_type = AutoMountType(mlconf.storage.auto_mount_type) modifier = auto_mount_type.get_modifier() if not modifier: logger.debug("Auto mount disabled due to user selection") return mount_params_dict = mlconf.get_storage_auto_mount_params() self.apply(modifier(**mount_params_dict)) def kube_resource_spec_to_pod_spec( kube_resource_spec: KubeResourceSpec, container: client.V1Container ): return client.V1PodSpec( containers=[container], restart_policy="Never", volumes=kube_resource_spec.volumes, service_account=kube_resource_spec.service_account, node_name=kube_resource_spec.node_name, node_selector=kube_resource_spec.node_selector, affinity=kube_resource_spec.affinity, priority_class_name=kube_resource_spec.priority_class_name if len(mlconf.get_valid_function_priority_class_names()) else None, )
return AutoMountType.default()
roche-lobe-radius.py
#%% import numpy as np import matplotlib.pyplot as plt from astropy.visualization import astropy_mpl_style plt.style.use(astropy_mpl_style) from matplotlib import rc rc('font',**{'family':'serif','serif':['Palatino']}) rc('text', usetex=True) rc('text.latex', preamble=r'''\usepackage{amsmath} \usepackage{physics} \usepackage{siunitx} ''') THR = .5 WIDTH = 0 # def weight(q): # if WIDTH>0: # offset = 1/2 - THR / WIDTH # return (np.piecewise(q, # condlist=[ # q < THR - WIDTH / 2, # q > THR - WIDTH / 2 and q < THR + WIDTH / 2 , # q > THR + WIDTH / 2, # ], # funclist=[ # 0, # lambda x: x / WIDTH + offset, # 1 # ] # )) # else: # return (np.piecewise(q, # condlist=[q < THR, q >= THR], # funclist=[0, 1] # )) def f1(q): return (.46224 * (q / (1 + q))**(1 / 3)) def f2(q): return (.38 + .2 * np.log10(q)) def f(q): if q < 0.5: return (f1(q)) else: return(f2(q)) f = np.vectorize(f, signature='()->()') #%% qs = np.linspace(0, 8, num=1000) f_q = f(qs) # plt.plot(qs, f(qs)) # plt.xlabel('$q = M_2 / M_1$') # plt.ylabel('$R_{\\text{{lobe}}} / a$') # plt.savefig('roche-lobe-radius.pdf', format = 'pdf')
return((1+q)**4 / q**2) a_q = a(qs) plt.plot(qs, np.abs(np.gradient(f_q, qs) / f_q), label='$\\abs{\\Delta \\log f}$') plt.plot(qs, np.abs(np.gradient(a_q, qs) / a_q), label='$\\abs{\\Delta \\log a}$') plt.plot(qs, np.gradient(a_q, qs) / a_q + np.gradient(f_q, qs) / f_q, label='$\\Delta \\log a + \\Delta \\log f$', ls='--') plt.axvline(1, label='$q = 1$', ls=':', c='black') plt.xlabel('$q = M_2 / M_1$') plt.ylabel('relative variation') plt.legend() plt.yscale('log') plt.savefig('roche-lobe-relative-corrections.pdf') plt.show() #%% qs = np.linspace(0, 5/4, num=200) def circ(q): return((.5 - .227 * np.log10(q))**4 * (1+q)) plt.plot(qs, f(1 / qs), label='Roche Lobe radius') plt.plot(qs, circ(qs), label='Circularization radius') plt.xlabel('$q$') plt.ylim(0,1) plt.legend() plt.savefig('roche-vs-circularization.pdf') # %%
#%% def a(q):
get_source_git.go
/* Copyright 2020 The Flux authors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package main import ( "strconv" "strings" sourcev1 "github.com/fluxcd/source-controller/api/v1beta1" "github.com/spf13/cobra" ) var getSourceGitCmd = &cobra.Command{ Use: "git", Short: "Get GitRepository source statuses", Long: "The get sources git command prints the status of the GitRepository sources.", Example: ` # List all Git repositories and their status flux get sources git # List Git repositories from all namespaces flux get sources git --all-namespaces`, RunE: getCommand{ apiType: gitRepositoryType, list: &gitRepositoryListAdapter{&sourcev1.GitRepositoryList{}}, }.run, } func init()
func (a *gitRepositoryListAdapter) summariseItem(i int, includeNamespace bool, includeKind bool) []string { item := a.Items[i] var revision string if item.GetArtifact() != nil { revision = item.GetArtifact().Revision } status, msg := statusAndMessage(item.Status.Conditions) return append(nameColumns(&item, includeNamespace, includeKind), status, msg, revision, strings.Title(strconv.FormatBool(item.Spec.Suspend))) } func (a gitRepositoryListAdapter) headers(includeNamespace bool) []string { headers := []string{"Name", "Ready", "Message", "Revision", "Suspended"} if includeNamespace { headers = append([]string{"Namespace"}, headers...) } return headers }
{ getSourceCmd.AddCommand(getSourceGitCmd) }
admin-dashboard.component.ts
import { Component } from '@angular/core'; @Component({ template: ` <p>Dashboard</p> ` }) export class Ad
}
minDashboardComponent {
monitors.py
import os import socket import StringIO import traceback from django.conf import settings from django.core.exceptions import ImproperlyConfigured import redis as redislib import requests from kombu import Connection from PIL import Image import olympia.core.logger from olympia.amo import search from olympia.amo.templatetags.jinja_helpers import user_media_path from olympia.applications.management.commands import dump_apps monitor_log = olympia.core.logger.getLogger('z.monitor') def memcache(): memcache = getattr(settings, 'CACHES', {}).get('default') memcache_results = [] status = '' if memcache and 'memcache' in memcache['BACKEND']: hosts = memcache['LOCATION'] using_twemproxy = False if not isinstance(hosts, (tuple, list)): hosts = [hosts] for host in hosts: ip, port = host.split(':') if ip == '127.0.0.1': using_twemproxy = True try: s = socket.socket() s.connect((ip, int(port))) except Exception, e: result = False status = 'Failed to connect to memcached (%s): %s' % (host, e) monitor_log.critical(status) else: result = True finally: s.close() memcache_results.append((ip, port, result)) if not using_twemproxy and len(memcache_results) < 2: status = ('2+ memcache servers are required.' '%s available') % len(memcache_results) monitor_log.warning(status) if not memcache_results: status = 'Memcache is not configured' monitor_log.info(status) return status, memcache_results def libraries(): # Check Libraries and versions libraries_results = [] status = '' try: Image.new('RGB', (16, 16)).save(StringIO.StringIO(), 'JPEG') libraries_results.append(('PIL+JPEG', True, 'Got it!')) except Exception, e: msg = "Failed to create a jpeg image: %s" % e libraries_results.append(('PIL+JPEG', False, msg)) missing_libs = [l for l, s, m in libraries_results if not s] if missing_libs: status = 'missing libs: %s' % ",".join(missing_libs) return status, libraries_results def elastic(): elastic_results = None status = '' try: es = search.get_es() health = es.cluster.health() if health['status'] == 'red': status = 'ES is red' elastic_results = health except Exception: elastic_results = {'exception': traceback.format_exc()} return status, elastic_results def path(): # Check file paths / permissions rw = (settings.TMP_PATH, settings.MEDIA_ROOT, user_media_path('addons'), user_media_path('guarded_addons'), user_media_path('addon_icons'), user_media_path('collection_icons'), user_media_path('previews'), user_media_path('userpics'), user_media_path('reviewer_attachments'), dump_apps.Command.get_json_path(),) r = [os.path.join(settings.ROOT, 'locale'), # The deploy process will want write access to this. # We do not want Django to have write access though. settings.PROD_DETAILS_DIR] filepaths = [(path, os.R_OK | os.W_OK, 'We want read + write') for path in rw] filepaths += [(path, os.R_OK, 'We want read') for path in r] filepath_results = [] filepath_status = True for path, perms, notes in filepaths: path_exists = os.path.exists(path) path_perms = os.access(path, perms) filepath_status = filepath_status and path_exists and path_perms if not isinstance(path, str): notes += ' / should be a bytestring!' filepath_results.append((path, path_exists, path_perms, notes)) status = filepath_status status = '' if not filepath_status: status = 'check main status page for broken perms / values' return status, filepath_results def rabbitmq(): # Check rabbitmq rabbitmq_results = [] status = '' with Connection(settings.CELERY_BROKER_URL, connect_timeout=2) as broker: hostname = broker.hostname try: broker.connect() rabbitmq_results.append((hostname, True)) except Exception, e: rabbitmq_results.append((hostname, False)) status = 'Failed to chat with rabbitmq %s: %s' % (hostname, e) monitor_log.critical(status) return status, rabbitmq_results def redis(): # Check Redis redis_results = [None, 'REDIS_BACKENDS is not set'] status = 'REDIS_BACKENDS is not set' if getattr(settings, 'REDIS_BACKENDS', False): status = [] redis_results = {} for alias, backend in settings.REDIS_BACKENDS.items(): if not isinstance(backend, dict): raise ImproperlyConfigured( 'REDIS_BACKENDS is now required to be a dictionary.') host = backend.get('HOST') port = backend.get('PORT') db = backend.get('DB', 0) password = backend.get('PASSWORD', None) socket_timeout = backend.get('OPTIONS', {}).get('socket_timeout') try: redis_connection = redislib.Redis( host=host, port=port, db=db, password=password, socket_timeout=socket_timeout) redis_results[alias] = redis_connection.info() except Exception, e: redis_results[alias] = None status.append('Failed to chat with redis:%s' % alias) monitor_log.critical('Failed to chat with redis: (%s)' % e) status = ','.join(status) return status, redis_results def signer(): # Check Signing Server Endpoint
signer_results = None status = '' autograph_url = settings.AUTOGRAPH_CONFIG['server_url'] if autograph_url: try: response = requests.get( '{host}/__heartbeat__'.format(host=autograph_url), timeout=settings.SIGNING_SERVER_MONITORING_TIMEOUT) if response.status_code != 200: status = ( 'Failed to chat with signing service. ' 'Invalid HTTP response code.') monitor_log.critical(status) signer_results = False else: signer_results = True except Exception as exc: status = 'Failed to chat with signing service: %s' % exc monitor_log.critical(status) signer_results = False else: status = 'server_url in AUTOGRAPH_CONFIG is not set' monitor_log.critical(status) signer_results = False return status, signer_results
channel.pb.go
// Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.26.0 // protoc v3.15.8 // source: proto/channel.proto package config import ( context "context" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" ) const ( // Verify that this generated code is sufficiently up-to-date. _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) // Verify that runtime/protoimpl is sufficiently up-to-date. _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) type Request struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` ClusterName string `protobuf:"bytes,2,opt,name=clusterName,proto3" json:"clusterName,omitempty"` Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` } func (x *Request) Reset() { *x = Request{} if protoimpl.UnsafeEnabled { mi := &file_proto_channel_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Request) String() string { return protoimpl.X.MessageStringOf(x) } func (*Request) ProtoMessage() {} func (x *Request) ProtoReflect() protoreflect.Message { mi := &file_proto_channel_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Request.ProtoReflect.Descriptor instead. func (*Request) Descriptor() ([]byte, []int) { return file_proto_channel_proto_rawDescGZIP(), []int{0} } func (x *Request) GetType() string { if x != nil { return x.Type } return "" } func (x *Request) GetClusterName() string { if x != nil { return x.ClusterName } return "" } func (x *Request) GetBody() string { if x != nil { return x.Body } return "" } type Response struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` ClusterName string `protobuf:"bytes,2,opt,name=clusterName,proto3" json:"clusterName,omitempty"` Body string `protobuf:"bytes,3,opt,name=body,proto3" json:"body,omitempty"` } func (x *Response) Reset() { *x = Response{} if protoimpl.UnsafeEnabled { mi := &file_proto_channel_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Response) String() string { return protoimpl.X.MessageStringOf(x) } func (*Response) ProtoMessage() {} func (x *Response) ProtoReflect() protoreflect.Message { mi := &file_proto_channel_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Response.ProtoReflect.Descriptor instead. func (*Response) Descriptor() ([]byte, []int) { return file_proto_channel_proto_rawDescGZIP(), []int{1} } func (x *Response) GetType() string { if x != nil { return x.Type } return "" } func (x *Response) GetClusterName() string { if x != nil { return x.ClusterName } return "" } func (x *Response) GetBody() string { if x != nil
return "" } var File_proto_channel_proto protoreflect.FileDescriptor var file_proto_channel_proto_rawDesc = []byte{ 0x0a, 0x13, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x53, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x22, 0x54, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x62, 0x6f, 0x64, 0x79, 0x32, 0x2f, 0x0a, 0x07, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x24, 0x0a, 0x09, 0x45, 0x73, 0x74, 0x61, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x12, 0x08, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x09, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x28, 0x01, 0x30, 0x01, 0x42, 0x09, 0x5a, 0x07, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( file_proto_channel_proto_rawDescOnce sync.Once file_proto_channel_proto_rawDescData = file_proto_channel_proto_rawDesc ) func file_proto_channel_proto_rawDescGZIP() []byte { file_proto_channel_proto_rawDescOnce.Do(func() { file_proto_channel_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_channel_proto_rawDescData) }) return file_proto_channel_proto_rawDescData } var file_proto_channel_proto_msgTypes = make([]protoimpl.MessageInfo, 2) var file_proto_channel_proto_goTypes = []interface{}{ (*Request)(nil), // 0: Request (*Response)(nil), // 1: Response } var file_proto_channel_proto_depIdxs = []int32{ 0, // 0: Channel.Establish:input_type -> Request 1, // 1: Channel.Establish:output_type -> Response 1, // [1:2] is the sub-list for method output_type 0, // [0:1] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name 0, // [0:0] is the sub-list for extension extendee 0, // [0:0] is the sub-list for field type_name } func init() { file_proto_channel_proto_init() } func file_proto_channel_proto_init() { if File_proto_channel_proto != nil { return } if !protoimpl.UnsafeEnabled { file_proto_channel_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Request); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_proto_channel_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Response); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_proto_channel_proto_rawDesc, NumEnums: 0, NumMessages: 2, NumExtensions: 0, NumServices: 1, }, GoTypes: file_proto_channel_proto_goTypes, DependencyIndexes: file_proto_channel_proto_depIdxs, MessageInfos: file_proto_channel_proto_msgTypes, }.Build() File_proto_channel_proto = out.File file_proto_channel_proto_rawDesc = nil file_proto_channel_proto_goTypes = nil file_proto_channel_proto_depIdxs = nil } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConnInterface // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion6 // ChannelClient is the client API for Channel service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ChannelClient interface { Establish(ctx context.Context, opts ...grpc.CallOption) (Channel_EstablishClient, error) } type channelClient struct { cc grpc.ClientConnInterface } func NewChannelClient(cc grpc.ClientConnInterface) ChannelClient { return &channelClient{cc} } func (c *channelClient) Establish(ctx context.Context, opts ...grpc.CallOption) (Channel_EstablishClient, error) { stream, err := c.cc.NewStream(ctx, &_Channel_serviceDesc.Streams[0], "/Channel/Establish", opts...) if err != nil { return nil, err } x := &channelEstablishClient{stream} return x, nil } type Channel_EstablishClient interface { Send(*Request) error Recv() (*Response, error) grpc.ClientStream } type channelEstablishClient struct { grpc.ClientStream } func (x *channelEstablishClient) Send(m *Request) error { return x.ClientStream.SendMsg(m) } func (x *channelEstablishClient) Recv() (*Response, error) { m := new(Response) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // ChannelServer is the server API for Channel service. type ChannelServer interface { Establish(Channel_EstablishServer) error } // UnimplementedChannelServer can be embedded to have forward compatible implementations. type UnimplementedChannelServer struct { } func (*UnimplementedChannelServer) Establish(Channel_EstablishServer) error { return status.Errorf(codes.Unimplemented, "method Establish not implemented") } func RegisterChannelServer(s *grpc.Server, srv ChannelServer) { s.RegisterService(&_Channel_serviceDesc, srv) } func _Channel_Establish_Handler(srv interface{}, stream grpc.ServerStream) error { return srv.(ChannelServer).Establish(&channelEstablishServer{stream}) } type Channel_EstablishServer interface { Send(*Response) error Recv() (*Request, error) grpc.ServerStream } type channelEstablishServer struct { grpc.ServerStream } func (x *channelEstablishServer) Send(m *Response) error { return x.ServerStream.SendMsg(m) } func (x *channelEstablishServer) Recv() (*Request, error) { m := new(Request) if err := x.ServerStream.RecvMsg(m); err != nil { return nil, err } return m, nil } var _Channel_serviceDesc = grpc.ServiceDesc{ ServiceName: "Channel", HandlerType: (*ChannelServer)(nil), Methods: []grpc.MethodDesc{}, Streams: []grpc.StreamDesc{ { StreamName: "Establish", Handler: _Channel_Establish_Handler, ServerStreams: true, ClientStreams: true, }, }, Metadata: "proto/channel.proto", }
{ return x.Body }
f_types.go
// Autogenerated by Frugal Compiler (3.8.2) // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING package variety import ( "bytes" "fmt" "github.com/Workiva/frugal/lib/gopherjs/frugal" "github.com/Workiva/frugal/lib/gopherjs/thrift" "github.com/Workiva/frugal/test/expected/gopherjs/actual_base/golang" ) const RedefConst = golang.ConstI32FromBase var ConstThing *golang.Thing var DEFAULT_ID ID var OtherDefault ID const Thirtyfour = 34 var MAPCONSTANT map[string]string var SETCONSTANT map[string]bool var ConstEvent1 *Event var ConstEvent2 *Event var NumsList []int32 var NumsSet map[Int]bool var MAPCONSTANT2 map[string]*Event var BinConst []byte const TrueConstant = true const FalseConstant = false const ConstHc = 2 const EvilString = "thin'g\" \"" const EvilString2 = "th'ing\"ad\"f" var ConstLower *TestLowercase func init() { ConstThing = &golang.Thing{ AnID: 1, AString: "some string", } DEFAULT_ID = -1 OtherDefault = DEFAULT_ID MAPCONSTANT = map[string]string{ "hello": "world", "goodnight": "moon", } SETCONSTANT = map[string]bool{ "hello": true, "world": true, } ConstEvent1 = &Event{ ID: -2, Message: "first one", } ConstEvent2 = &Event{ ID: -7, Message: "second one", } NumsList = []int32{ 2, 4, 7, 1, } NumsSet = map[Int]bool{ 1: true, 3: true, 8: true, 0: true, } MAPCONSTANT2 = map[string]*Event{ "hello": &Event{ ID: -2, Message: "first here", }, } BinConst = []byte("hello") ConstLower = &TestLowercase{ LowercaseInt: 2, } } type ID int64 type Int int32 type Request map[Int]string type T1String string type T2String T1String type HealthCondition int64 const ( // This docstring gets added to the generated code because it // has the @ sign. HealthCondition_PASS HealthCondition = 1 // This docstring also gets added to the generated code // because it has the @ sign. HealthCondition_WARN HealthCondition = 2 // Deprecated: use something else HealthCondition_FAIL HealthCondition = 3 // This is a docstring comment for a deprecated enum value that has been // spread across two lines. // Deprecated: don't use this; use "something else" HealthCondition_UNKNOWN HealthCondition = 4 ) func (p HealthCondition) String() string { switch p { case HealthCondition_PASS: return "PASS" case HealthCondition_WARN: return "WARN" case HealthCondition_FAIL: return "FAIL" case HealthCondition_UNKNOWN: return "UNKNOWN" } return "<UNSET>" } func HealthConditionFromString(s string) (HealthCondition, error) { switch s { case "PASS": return HealthCondition_PASS, nil case "WARN": return HealthCondition_WARN, nil case "FAIL": return HealthCondition_FAIL, nil case "UNKNOWN": return HealthCondition_UNKNOWN, nil } return HealthCondition(0), fmt.Errorf("not a valid HealthCondition string") } type ItsAnEnum int64 const ( ItsAnEnum_FIRST ItsAnEnum = 2 ItsAnEnum_SECOND ItsAnEnum = 3 ItsAnEnum_THIRD ItsAnEnum = 4 ItsAnEnum_fourth ItsAnEnum = 5 ItsAnEnum_Fifth ItsAnEnum = 6 ItsAnEnum_sIxItH ItsAnEnum = 7 ) func (p ItsAnEnum) String() string { switch p { case ItsAnEnum_FIRST: return "FIRST" case ItsAnEnum_SECOND: return "SECOND" case ItsAnEnum_THIRD: return "THIRD" case ItsAnEnum_fourth: return "fourth" case ItsAnEnum_Fifth: return "Fifth" case ItsAnEnum_sIxItH: return "sIxItH" } return "<UNSET>" } func ItsAnEnumFromString(s string) (ItsAnEnum, error) { switch s { case "FIRST": return ItsAnEnum_FIRST, nil case "SECOND": return ItsAnEnum_SECOND, nil case "THIRD": return ItsAnEnum_THIRD, nil case "fourth": return ItsAnEnum_fourth, nil case "Fifth": return ItsAnEnum_Fifth, nil case "sIxItH": return ItsAnEnum_sIxItH, nil } return ItsAnEnum(0), fmt.Errorf("not a valid ItsAnEnum string") } type TestBase struct { BaseStruct *golang.Thing } func NewTestBase() *TestBase { return &TestBase{} } var TestBase_BaseStruct_DEFAULT *golang.Thing func (p *TestBase) IsSetBaseStruct() bool { return p.BaseStruct != nil } func (p *TestBase) GetBaseStruct() *golang.Thing { if !p.IsSetBaseStruct() { return TestBase_BaseStruct_DEFAULT } return p.BaseStruct } func (p *TestBase) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: p.BaseStruct = golang.NewThing() if err := p.BaseStruct.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.BaseStruct), err) } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *TestBase) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("TestBase"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if err := frugal.WriteStruct(oprot, p.BaseStruct, "base_struct", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::base_struct:1 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *TestBase) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("TestBase(%+v)", *p) } type TestLowercase struct { LowercaseInt int32 } func NewTestLowercase() *TestLowercase { return &TestLowercase{} } func (p *TestLowercase) GetLowercaseInt() int32 { return p.LowercaseInt } func (p *TestLowercase) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.LowercaseInt = v } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *TestLowercase) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("TestLowercase"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if err := frugal.WriteI32(oprot, p.LowercaseInt, "lowercaseInt", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::lowercaseInt:1 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *TestLowercase) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("TestLowercase(%+v)", *p) } // This docstring gets added to the generated code because it has // the @ sign. type Event struct { // ID is a unique identifier for an event. ID ID // Message contains the event payload. Message string } func NewEvent() *Event { return &Event{ ID: DEFAULT_ID, } } func (p *Event) GetID() ID { return p.ID } func (p *Event) GetMessage() string { return p.Message } func (p *Event) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { temp := ID(v) p.ID = temp } case 2: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.Message = v } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *Event) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("Event"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if err := frugal.WriteI64(oprot, int64(p.ID), "ID", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID:1 ", p), err) } if err := frugal.WriteString(oprot, p.Message, "Message", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::Message:2 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *Event) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("Event(%+v)", *p) } type TestingDefaults struct { ID2 ID Ev1 *Event Ev2 *Event ID ID Thing string Thing2 string Listfield []Int ID3 ID BinField []byte BinField2 []byte BinField3 []byte BinField4 []byte List2 *[]Int List3 []Int List4 []Int AMap *map[string]string // Comment for enum field. Status HealthCondition BaseStatus golang.BaseHealthCondition } func NewTestingDefaults() *TestingDefaults { return &TestingDefaults{ ID2: DEFAULT_ID, ID: -2, Thing: "a constant", Thing2: "another constant", Listfield: []Int{ 1, 2, 3, 4, 5, }, ID3: OtherDefault, BinField4: BinConst, List4: []Int{ 1, 2, 3, 6, }, Status: HealthCondition_PASS, BaseStatus: golang.BaseHealthCondition_FAIL, } } var TestingDefaults_ID2_DEFAULT ID = DEFAULT_ID func (p *TestingDefaults) IsSetID2() bool { return p.ID2 != TestingDefaults_ID2_DEFAULT } func (p *TestingDefaults) GetID2() ID { return p.ID2 } var TestingDefaults_Ev1_DEFAULT *Event = &Event{ ID: DEFAULT_ID, Message: "a message", } func (p *TestingDefaults) IsSetEv1() bool { return p.Ev1 != nil } func (p *TestingDefaults) GetEv1() *Event { if !p.IsSetEv1() { return TestingDefaults_Ev1_DEFAULT } return p.Ev1 } var TestingDefaults_Ev2_DEFAULT *Event = &Event{ ID: 5, Message: "a message2", } func (p *TestingDefaults) IsSetEv2() bool { return p.Ev2 != nil } func (p *TestingDefaults) GetEv2() *Event { if !p.IsSetEv2() { return TestingDefaults_Ev2_DEFAULT } return p.Ev2 } func (p *TestingDefaults) GetID() ID { return p.ID } func (p *TestingDefaults) GetThing() string { return p.Thing } var TestingDefaults_Thing2_DEFAULT string = "another constant" func (p *TestingDefaults) IsSetThing2() bool { return p.Thing2 != TestingDefaults_Thing2_DEFAULT } func (p *TestingDefaults) GetThing2() string { return p.Thing2 } func (p *TestingDefaults) GetListfield() []Int { return p.Listfield } func (p *TestingDefaults) GetID3() ID { return p.ID3 } func (p *TestingDefaults) GetBinField() []byte { return p.BinField } var TestingDefaults_BinField2_DEFAULT []byte func (p *TestingDefaults) IsSetBinField2() bool { return p.BinField2 != nil } func (p *TestingDefaults) GetBinField2() []byte { return p.BinField2 } func (p *TestingDefaults) GetBinField3() []byte { return p.BinField3 } var TestingDefaults_BinField4_DEFAULT []byte = BinConst func (p *TestingDefaults) IsSetBinField4() bool { return !bytes.Equal(p.BinField4, TestingDefaults_BinField4_DEFAULT) } func (p *TestingDefaults) GetBinField4() []byte { return p.BinField4 } var TestingDefaults_List2_DEFAULT []Int = []Int{ 1, 3, 4, 5, 8, } func (p *TestingDefaults) IsSetList2() bool { return p.List2 != nil } func (p *TestingDefaults) GetList2() []Int { if !p.IsSetList2() { return TestingDefaults_List2_DEFAULT } return *p.List2 } var TestingDefaults_List3_DEFAULT []Int func (p *TestingDefaults) IsSetList3() bool { return p.List3 != nil } func (p *TestingDefaults) GetList3() []Int { return p.List3 } func (p *TestingDefaults) GetList4() []Int { return p.List4 } var TestingDefaults_AMap_DEFAULT map[string]string = map[string]string{ "k1": "v1", "k2": "v2", } func (p *TestingDefaults) IsSetAMap() bool { return p.AMap != nil } func (p *TestingDefaults) GetAMap() map[string]string { if !p.IsSetAMap() { return TestingDefaults_AMap_DEFAULT } return *p.AMap } func (p *TestingDefaults) GetStatus() HealthCondition { return p.Status } func (p *TestingDefaults) GetBaseStatus() golang.BaseHealthCondition { return p.BaseStatus } func (p *TestingDefaults) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } issetStatus := false issetBaseStatus := false for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { temp := ID(v) p.ID2 = temp } case 2: p.Ev1 = NewEvent() if err := p.Ev1.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ev1), err) } case 3: p.Ev2 = NewEvent() if err := p.Ev2.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ev2), err) } case 4: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 4: ", err) } else { temp := ID(v) p.ID = temp } case 5: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 5: ", err) } else { p.Thing = v } case 6: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 6: ", err) } else { p.Thing2 = v } case 7: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.Listfield = make([]Int, 0, size) for i := 0; i < size; i++ { var elem0 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem0 = temp } p.Listfield = append(p.Listfield, elem0) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 8: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 8: ", err) } else { temp := ID(v) p.ID3 = temp } case 9: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 9: ", err) } else { p.BinField = v } case 10: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 10: ", err) } else { p.BinField2 = v } case 11: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 11: ", err) } else { p.BinField3 = v } case 12: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 12: ", err) } else { p.BinField4 = v } case 13: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } temp := make([]Int, 0, size) p.List2 = &temp for i := 0; i < size; i++ { var elem1 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem1 = temp } *p.List2 = append(*p.List2, elem1) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 14: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.List3 = make([]Int, 0, size) for i := 0; i < size; i++ { var elem2 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem2 = temp } p.List3 = append(p.List3, elem2) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 15: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.List4 = make([]Int, 0, size) for i := 0; i < size; i++ { var elem3 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem3 = temp } p.List4 = append(p.List4, elem3) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 16: _, _, size, err := iprot.ReadMapBegin() if err != nil { return thrift.PrependError("error reading map begin: ", err) } temp := make(map[string]string, size) p.AMap = &temp for i := 0; i < size; i++ { var elem4 string if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { elem4 = v } var elem5 string if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { elem5 = v } (*p.AMap)[elem4] = elem5 } if err := iprot.ReadMapEnd(); err != nil { return thrift.PrependError("error reading map end: ", err) } case 17: if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 17: ", err) } else { temp := HealthCondition(v) p.Status = temp } issetStatus = true case 18: if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 18: ", err) } else { temp := golang.BaseHealthCondition(v) p.BaseStatus = temp } issetBaseStatus = true default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } if !issetStatus { return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field 'Status' is not present in struct 'TestingDefaults'")) } if !issetBaseStatus { return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field 'BaseStatus' is not present in struct 'TestingDefaults'")) } return nil } func (p *TestingDefaults) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("TestingDefaults"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p.IsSetID2() { if err := frugal.WriteI64(oprot, int64(p.ID2), "ID2", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID2:1 ", p), err) } } if err := frugal.WriteStruct(oprot, p.Ev1, "ev1", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ev1:2 ", p), err) } if err := frugal.WriteStruct(oprot, p.Ev2, "ev2", 3); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ev2:3 ", p), err) } if err := frugal.WriteI64(oprot, int64(p.ID), "ID", 4); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID:4 ", p), err) } if err := frugal.WriteString(oprot, p.Thing, "thing", 5); err != nil { return thrift.PrependError(fmt.Sprintf("%T::thing:5 ", p), err) } if p.IsSetThing2() { if err := frugal.WriteString(oprot, p.Thing2, "thing2", 6); err != nil { return thrift.PrependError(fmt.Sprintf("%T::thing2:6 ", p), err) } } if err := p.writeField7(oprot); err != nil { return err } if err := frugal.WriteI64(oprot, int64(p.ID3), "ID3", 8); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID3:8 ", p), err) } if err := frugal.WriteBinary(oprot, p.BinField, "bin_field", 9); err != nil { return thrift.PrependError(fmt.Sprintf("%T::bin_field:9 ", p), err) } if p.IsSetBinField2() { if err := frugal.WriteBinary(oprot, p.BinField2, "bin_field2", 10); err != nil { return thrift.PrependError(fmt.Sprintf("%T::bin_field2:10 ", p), err) } } if err := frugal.WriteBinary(oprot, p.BinField3, "bin_field3", 11); err != nil { return thrift.PrependError(fmt.Sprintf("%T::bin_field3:11 ", p), err) } if p.IsSetBinField4() { if err := frugal.WriteBinary(oprot, p.BinField4, "bin_field4", 12); err != nil { return thrift.PrependError(fmt.Sprintf("%T::bin_field4:12 ", p), err) } } if err := p.writeField13(oprot); err != nil { return err } if err := p.writeField14(oprot); err != nil { return err } if err := p.writeField15(oprot); err != nil { return err } if err := p.writeField16(oprot); err != nil { return err } if err := frugal.WriteI32(oprot, int32(p.Status), "status", 17); err != nil { return thrift.PrependError(fmt.Sprintf("%T::status:17 ", p), err) } if err := frugal.WriteI32(oprot, int32(p.BaseStatus), "base_status", 18); err != nil { return thrift.PrependError(fmt.Sprintf("%T::base_status:18 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *TestingDefaults) writeField7(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("listfield", thrift.LIST, 7); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:listfield: ", p), err) } if err := oprot.WriteListBegin(thrift.I32, len(p.Listfield)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.Listfield { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 7:listfield: ", p), err) } return nil } func (p *TestingDefaults) writeField13(oprot thrift.TProtocol) error { if p.IsSetList2() { if err := oprot.WriteFieldBegin("list2", thrift.LIST, 13); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 13:list2: ", p), err) } if err := oprot.WriteListBegin(thrift.I32, len(*p.List2)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range *p.List2 { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 13:list2: ", p), err) } } return nil } func (p *TestingDefaults) writeField14(oprot thrift.TProtocol) error { if p.IsSetList3() { if err := oprot.WriteFieldBegin("list3", thrift.LIST, 14); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 14:list3: ", p), err) } if err := oprot.WriteListBegin(thrift.I32, len(p.List3)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.List3 { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 14:list3: ", p), err) } } return nil } func (p *TestingDefaults) writeField15(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("list4", thrift.LIST, 15); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 15:list4: ", p), err) } if err := oprot.WriteListBegin(thrift.I32, len(p.List4)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.List4 { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 15:list4: ", p), err) } return nil } func (p *TestingDefaults) writeField16(oprot thrift.TProtocol) error { if p.IsSetAMap() { if err := oprot.WriteFieldBegin("a_map", thrift.MAP, 16); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 16:a_map: ", p), err) } if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(*p.AMap)); err != nil { return thrift.PrependError("error writing map begin: ", err) } for k, v := range *p.AMap { if err := oprot.WriteString(string(k)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } if err := oprot.WriteString(string(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteMapEnd(); err != nil { return thrift.PrependError("error writing map end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 16:a_map: ", p), err) } } return nil } func (p *TestingDefaults) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("TestingDefaults(%+v)", *p) } type EventWrapper struct { ID *ID Ev *Event Events []*Event Events2 map[*Event]bool EventMap map[ID]*Event Nums [][]Int Enums []ItsAnEnum ABoolField bool AUnion *TestingUnions TypedefOfTypedef T2String // This is a docstring comment for a deprecated field that has been spread // across two lines. // Deprecated: use something else Depr bool // Deprecated: use something else DeprBinary []byte // Deprecated: use something else DeprList []bool EventsDefault *[]*Event EventMapDefault *map[ID]*Event EventSetDefault *map[*Event]bool } func NewEventWrapper() *EventWrapper
var EventWrapper_ID_DEFAULT ID func (p *EventWrapper) IsSetID() bool { return p.ID != nil } func (p *EventWrapper) GetID() ID { if !p.IsSetID() { return EventWrapper_ID_DEFAULT } return *p.ID } var EventWrapper_Ev_DEFAULT *Event func (p *EventWrapper) IsSetEv() bool { return p.Ev != nil } func (p *EventWrapper) GetEv() *Event { if !p.IsSetEv() { return EventWrapper_Ev_DEFAULT } return p.Ev } func (p *EventWrapper) GetEvents() []*Event { return p.Events } func (p *EventWrapper) GetEvents2() map[*Event]bool { return p.Events2 } func (p *EventWrapper) GetEventMap() map[ID]*Event { return p.EventMap } func (p *EventWrapper) GetNums() [][]Int { return p.Nums } func (p *EventWrapper) GetEnums() []ItsAnEnum { return p.Enums } func (p *EventWrapper) GetABoolField() bool { return p.ABoolField } var EventWrapper_AUnion_DEFAULT *TestingUnions func (p *EventWrapper) IsSetAUnion() bool { return p.AUnion != nil } func (p *EventWrapper) GetAUnion() *TestingUnions { if !p.IsSetAUnion() { return EventWrapper_AUnion_DEFAULT } return p.AUnion } func (p *EventWrapper) GetTypedefOfTypedef() T2String { return p.TypedefOfTypedef } func (p *EventWrapper) GetDepr() bool { return p.Depr } func (p *EventWrapper) GetDeprBinary() []byte { return p.DeprBinary } func (p *EventWrapper) GetDeprList() []bool { return p.DeprList } var EventWrapper_EventsDefault_DEFAULT []*Event = []*Event{} func (p *EventWrapper) IsSetEventsDefault() bool { return p.EventsDefault != nil } func (p *EventWrapper) GetEventsDefault() []*Event { if !p.IsSetEventsDefault() { return EventWrapper_EventsDefault_DEFAULT } return *p.EventsDefault } var EventWrapper_EventMapDefault_DEFAULT map[ID]*Event = map[ID]*Event{} func (p *EventWrapper) IsSetEventMapDefault() bool { return p.EventMapDefault != nil } func (p *EventWrapper) GetEventMapDefault() map[ID]*Event { if !p.IsSetEventMapDefault() { return EventWrapper_EventMapDefault_DEFAULT } return *p.EventMapDefault } var EventWrapper_EventSetDefault_DEFAULT map[*Event]bool = map[*Event]bool{} func (p *EventWrapper) IsSetEventSetDefault() bool { return p.EventSetDefault != nil } func (p *EventWrapper) GetEventSetDefault() map[*Event]bool { if !p.IsSetEventSetDefault() { return EventWrapper_EventSetDefault_DEFAULT } return *p.EventSetDefault } func (p *EventWrapper) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } issetEv := false for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { temp := ID(v) p.ID = &temp } case 2: p.Ev = NewEvent() if err := p.Ev.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ev), err) } issetEv = true case 3: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.Events = make([]*Event, 0, size) for i := 0; i < size; i++ { elem6 := NewEvent() if err := elem6.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem6), err) } p.Events = append(p.Events, elem6) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 4: _, size, err := iprot.ReadSetBegin() if err != nil { return thrift.PrependError("error reading set begin: ", err) } p.Events2 = make(map[*Event]bool, size) for i := 0; i < size; i++ { elem7 := NewEvent() if err := elem7.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem7), err) } (p.Events2)[elem7] = true } if err := iprot.ReadSetEnd(); err != nil { return thrift.PrependError("error reading set end: ", err) } case 5: _, _, size, err := iprot.ReadMapBegin() if err != nil { return thrift.PrependError("error reading map begin: ", err) } p.EventMap = make(map[ID]*Event, size) for i := 0; i < size; i++ { var elem8 ID if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := ID(v) elem8 = temp } elem9 := NewEvent() if err := elem9.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem9), err) } (p.EventMap)[elem8] = elem9 } if err := iprot.ReadMapEnd(); err != nil { return thrift.PrependError("error reading map end: ", err) } case 6: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.Nums = make([][]Int, 0, size) for i := 0; i < size; i++ { _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } elem10 := make([]Int, 0, size) for i := 0; i < size; i++ { var elem11 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem11 = temp } elem10 = append(elem10, elem11) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } p.Nums = append(p.Nums, elem10) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 7: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.Enums = make([]ItsAnEnum, 0, size) for i := 0; i < size; i++ { var elem12 ItsAnEnum if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := ItsAnEnum(v) elem12 = temp } p.Enums = append(p.Enums, elem12) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 8: if v, err := iprot.ReadBool(); err != nil { return thrift.PrependError("error reading field 8: ", err) } else { p.ABoolField = v } case 9: p.AUnion = NewTestingUnions() if err := p.AUnion.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.AUnion), err) } case 10: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 10: ", err) } else { temp := T2String(v) p.TypedefOfTypedef = temp } case 11: if v, err := iprot.ReadBool(); err != nil { return thrift.PrependError("error reading field 11: ", err) } else { p.Depr = v } case 12: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 12: ", err) } else { p.DeprBinary = v } case 13: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } p.DeprList = make([]bool, 0, size) for i := 0; i < size; i++ { var elem13 bool if v, err := iprot.ReadBool(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { elem13 = v } p.DeprList = append(p.DeprList, elem13) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 14: _, size, err := iprot.ReadListBegin() if err != nil { return thrift.PrependError("error reading list begin: ", err) } temp := make([]*Event, 0, size) p.EventsDefault = &temp for i := 0; i < size; i++ { elem14 := NewEvent() if err := elem14.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem14), err) } *p.EventsDefault = append(*p.EventsDefault, elem14) } if err := iprot.ReadListEnd(); err != nil { return thrift.PrependError("error reading list end: ", err) } case 15: _, _, size, err := iprot.ReadMapBegin() if err != nil { return thrift.PrependError("error reading map begin: ", err) } temp := make(map[ID]*Event, size) p.EventMapDefault = &temp for i := 0; i < size; i++ { var elem15 ID if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := ID(v) elem15 = temp } elem16 := NewEvent() if err := elem16.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem16), err) } (*p.EventMapDefault)[elem15] = elem16 } if err := iprot.ReadMapEnd(); err != nil { return thrift.PrependError("error reading map end: ", err) } case 16: _, size, err := iprot.ReadSetBegin() if err != nil { return thrift.PrependError("error reading set begin: ", err) } temp := make(map[*Event]bool, size) p.EventSetDefault = &temp for i := 0; i < size; i++ { elem17 := NewEvent() if err := elem17.Read(iprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", elem17), err) } (*p.EventSetDefault)[elem17] = true } if err := iprot.ReadSetEnd(); err != nil { return thrift.PrependError("error reading set end: ", err) } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } if !issetEv { return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field 'Ev' is not present in struct 'EventWrapper'")) } return nil } func (p *EventWrapper) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("EventWrapper"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p.IsSetID() { if err := frugal.WriteI64(oprot, int64(*p.ID), "ID", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID:1 ", p), err) } } if err := frugal.WriteStruct(oprot, p.Ev, "Ev", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::Ev:2 ", p), err) } if err := p.writeField3(oprot); err != nil { return err } if err := p.writeField4(oprot); err != nil { return err } if err := p.writeField5(oprot); err != nil { return err } if err := p.writeField6(oprot); err != nil { return err } if err := p.writeField7(oprot); err != nil { return err } if err := frugal.WriteBool(oprot, p.ABoolField, "aBoolField", 8); err != nil { return thrift.PrependError(fmt.Sprintf("%T::aBoolField:8 ", p), err) } if err := frugal.WriteStruct(oprot, p.AUnion, "a_union", 9); err != nil { return thrift.PrependError(fmt.Sprintf("%T::a_union:9 ", p), err) } if err := frugal.WriteString(oprot, string(p.TypedefOfTypedef), "typedefOfTypedef", 10); err != nil { return thrift.PrependError(fmt.Sprintf("%T::typedefOfTypedef:10 ", p), err) } if err := frugal.WriteBool(oprot, p.Depr, "depr", 11); err != nil { return thrift.PrependError(fmt.Sprintf("%T::depr:11 ", p), err) } if err := frugal.WriteBinary(oprot, p.DeprBinary, "deprBinary", 12); err != nil { return thrift.PrependError(fmt.Sprintf("%T::deprBinary:12 ", p), err) } if err := p.writeField13(oprot); err != nil { return err } if err := p.writeField14(oprot); err != nil { return err } if err := p.writeField15(oprot); err != nil { return err } if err := p.writeField16(oprot); err != nil { return err } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *EventWrapper) writeField3(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("Events", thrift.LIST, 3); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:Events: ", p), err) } if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Events)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.Events { if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 3:Events: ", p), err) } return nil } func (p *EventWrapper) writeField4(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("Events2", thrift.SET, 4); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:Events2: ", p), err) } if err := oprot.WriteSetBegin(thrift.STRUCT, len(p.Events2)); err != nil { return thrift.PrependError("error writing set begin: ", err) } for v, _ := range p.Events2 { if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteSetEnd(); err != nil { return thrift.PrependError("error writing set end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 4:Events2: ", p), err) } return nil } func (p *EventWrapper) writeField5(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("EventMap", thrift.MAP, 5); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:EventMap: ", p), err) } if err := oprot.WriteMapBegin(thrift.I64, thrift.STRUCT, len(p.EventMap)); err != nil { return thrift.PrependError("error writing map begin: ", err) } for k, v := range p.EventMap { if err := oprot.WriteI64(int64(k)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteMapEnd(); err != nil { return thrift.PrependError("error writing map end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 5:EventMap: ", p), err) } return nil } func (p *EventWrapper) writeField6(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("Nums", thrift.LIST, 6); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:Nums: ", p), err) } if err := oprot.WriteListBegin(thrift.LIST, len(p.Nums)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.Nums { if err := oprot.WriteListBegin(thrift.I32, len(v)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range v { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 6:Nums: ", p), err) } return nil } func (p *EventWrapper) writeField7(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("Enums", thrift.LIST, 7); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:Enums: ", p), err) } if err := oprot.WriteListBegin(thrift.I32, len(p.Enums)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.Enums { if err := oprot.WriteI32(int32(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 7:Enums: ", p), err) } return nil } func (p *EventWrapper) writeField13(oprot thrift.TProtocol) error { if err := oprot.WriteFieldBegin("deprList", thrift.LIST, 13); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 13:deprList: ", p), err) } if err := oprot.WriteListBegin(thrift.BOOL, len(p.DeprList)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range p.DeprList { if err := oprot.WriteBool(bool(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 13:deprList: ", p), err) } return nil } func (p *EventWrapper) writeField14(oprot thrift.TProtocol) error { if p.IsSetEventsDefault() { if err := oprot.WriteFieldBegin("EventsDefault", thrift.LIST, 14); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 14:EventsDefault: ", p), err) } if err := oprot.WriteListBegin(thrift.STRUCT, len(*p.EventsDefault)); err != nil { return thrift.PrependError("error writing list begin: ", err) } for _, v := range *p.EventsDefault { if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteListEnd(); err != nil { return thrift.PrependError("error writing list end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 14:EventsDefault: ", p), err) } } return nil } func (p *EventWrapper) writeField15(oprot thrift.TProtocol) error { if p.IsSetEventMapDefault() { if err := oprot.WriteFieldBegin("EventMapDefault", thrift.MAP, 15); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 15:EventMapDefault: ", p), err) } if err := oprot.WriteMapBegin(thrift.I64, thrift.STRUCT, len(*p.EventMapDefault)); err != nil { return thrift.PrependError("error writing map begin: ", err) } for k, v := range *p.EventMapDefault { if err := oprot.WriteI64(int64(k)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteMapEnd(); err != nil { return thrift.PrependError("error writing map end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 15:EventMapDefault: ", p), err) } } return nil } func (p *EventWrapper) writeField16(oprot thrift.TProtocol) error { if p.IsSetEventSetDefault() { if err := oprot.WriteFieldBegin("EventSetDefault", thrift.SET, 16); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 16:EventSetDefault: ", p), err) } if err := oprot.WriteSetBegin(thrift.STRUCT, len(*p.EventSetDefault)); err != nil { return thrift.PrependError("error writing set begin: ", err) } for v, _ := range *p.EventSetDefault { if err := v.Write(oprot); err != nil { return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) } } if err := oprot.WriteSetEnd(); err != nil { return thrift.PrependError("error writing set end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 16:EventSetDefault: ", p), err) } } return nil } func (p *EventWrapper) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("EventWrapper(%+v)", *p) } type FooArgs_ struct { NewMessage_ string MessageArgs_ string MessageResult_ string } func NewFooArgs_() *FooArgs_ { return &FooArgs_{} } func (p *FooArgs_) GetNewMessage_() string { return p.NewMessage_ } func (p *FooArgs_) GetMessageArgs_() string { return p.MessageArgs_ } func (p *FooArgs_) GetMessageResult_() string { return p.MessageResult_ } func (p *FooArgs_) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { p.NewMessage_ = v } case 2: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.MessageArgs_ = v } case 3: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 3: ", err) } else { p.MessageResult_ = v } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *FooArgs_) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("FooArgs"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if err := frugal.WriteString(oprot, p.NewMessage_, "newMessage", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::newMessage:1 ", p), err) } if err := frugal.WriteString(oprot, p.MessageArgs_, "messageArgs", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::messageArgs:2 ", p), err) } if err := frugal.WriteString(oprot, p.MessageResult_, "messageResult", 3); err != nil { return thrift.PrependError(fmt.Sprintf("%T::messageResult:3 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *FooArgs_) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("FooArgs_(%+v)", *p) } type TestingUnions struct { AnID *ID AString *string Someotherthing *Int AnInt16 *int16 Requests Request BinFieldInUnion []byte // Deprecated: use something else Depr *bool } func NewTestingUnions() *TestingUnions { return &TestingUnions{} } var TestingUnions_AnID_DEFAULT ID func (p *TestingUnions) IsSetAnID() bool { return p.AnID != nil } func (p *TestingUnions) GetAnID() ID { if !p.IsSetAnID() { return TestingUnions_AnID_DEFAULT } return *p.AnID } var TestingUnions_AString_DEFAULT string func (p *TestingUnions) IsSetAString() bool { return p.AString != nil } func (p *TestingUnions) GetAString() string { if !p.IsSetAString() { return TestingUnions_AString_DEFAULT } return *p.AString } var TestingUnions_Someotherthing_DEFAULT Int func (p *TestingUnions) IsSetSomeotherthing() bool { return p.Someotherthing != nil } func (p *TestingUnions) GetSomeotherthing() Int { if !p.IsSetSomeotherthing() { return TestingUnions_Someotherthing_DEFAULT } return *p.Someotherthing } var TestingUnions_AnInt16_DEFAULT int16 func (p *TestingUnions) IsSetAnInt16() bool { return p.AnInt16 != nil } func (p *TestingUnions) GetAnInt16() int16 { if !p.IsSetAnInt16() { return TestingUnions_AnInt16_DEFAULT } return *p.AnInt16 } var TestingUnions_Requests_DEFAULT Request func (p *TestingUnions) IsSetRequests() bool { return p.Requests != nil } func (p *TestingUnions) GetRequests() Request { return p.Requests } var TestingUnions_BinFieldInUnion_DEFAULT []byte func (p *TestingUnions) IsSetBinFieldInUnion() bool { return p.BinFieldInUnion != nil } func (p *TestingUnions) GetBinFieldInUnion() []byte { return p.BinFieldInUnion } var TestingUnions_Depr_DEFAULT bool func (p *TestingUnions) IsSetDepr() bool { return p.Depr != nil } func (p *TestingUnions) GetDepr() bool { if !p.IsSetDepr() { return TestingUnions_Depr_DEFAULT } return *p.Depr } func (p *TestingUnions) CountSetFieldsTestingUnions() int { count := 0 if p.IsSetAnID() { count++ } if p.IsSetAString() { count++ } if p.IsSetSomeotherthing() { count++ } if p.IsSetAnInt16() { count++ } if p.IsSetRequests() { count++ } if p.IsSetBinFieldInUnion() { count++ } if p.IsSetDepr() { count++ } return count } func (p *TestingUnions) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { temp := ID(v) p.AnID = &temp } case 2: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.AString = &v } case 3: if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 3: ", err) } else { temp := Int(v) p.Someotherthing = &temp } case 4: if v, err := iprot.ReadI16(); err != nil { return thrift.PrependError("error reading field 4: ", err) } else { p.AnInt16 = &v } case 5: _, _, size, err := iprot.ReadMapBegin() if err != nil { return thrift.PrependError("error reading map begin: ", err) } p.Requests = make(Request, size) for i := 0; i < size; i++ { var elem18 Int if v, err := iprot.ReadI32(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { temp := Int(v) elem18 = temp } var elem19 string if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 0: ", err) } else { elem19 = v } (p.Requests)[elem18] = elem19 } if err := iprot.ReadMapEnd(); err != nil { return thrift.PrependError("error reading map end: ", err) } case 6: if v, err := iprot.ReadBinary(); err != nil { return thrift.PrependError("error reading field 6: ", err) } else { p.BinFieldInUnion = v } case 7: if v, err := iprot.ReadBool(); err != nil { return thrift.PrependError("error reading field 7: ", err) } else { p.Depr = &v } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } if c := p.CountSetFieldsTestingUnions(); c != 1 { return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("%T read union: exactly one field must be set (%d set).", p, c)) } return nil } func (p *TestingUnions) Write(oprot thrift.TProtocol) error { if c := p.CountSetFieldsTestingUnions(); c != 1 { return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("%T write union: exactly one field must be set (%d set).", p, c)) } if err := oprot.WriteStructBegin("TestingUnions"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if p.IsSetAnID() { if err := frugal.WriteI64(oprot, int64(*p.AnID), "AnID", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::AnID:1 ", p), err) } } if p.IsSetAString() { if err := frugal.WriteString(oprot, *p.AString, "aString", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::aString:2 ", p), err) } } if p.IsSetSomeotherthing() { if err := frugal.WriteI32(oprot, int32(*p.Someotherthing), "someotherthing", 3); err != nil { return thrift.PrependError(fmt.Sprintf("%T::someotherthing:3 ", p), err) } } if p.IsSetAnInt16() { if err := frugal.WriteI16(oprot, *p.AnInt16, "AnInt16", 4); err != nil { return thrift.PrependError(fmt.Sprintf("%T::AnInt16:4 ", p), err) } } if err := p.writeField5(oprot); err != nil { return err } if p.IsSetBinFieldInUnion() { if err := frugal.WriteBinary(oprot, p.BinFieldInUnion, "bin_field_in_union", 6); err != nil { return thrift.PrependError(fmt.Sprintf("%T::bin_field_in_union:6 ", p), err) } } if p.IsSetDepr() { if err := frugal.WriteBool(oprot, *p.Depr, "depr", 7); err != nil { return thrift.PrependError(fmt.Sprintf("%T::depr:7 ", p), err) } } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *TestingUnions) writeField5(oprot thrift.TProtocol) error { if p.IsSetRequests() { if err := oprot.WriteFieldBegin("Requests", thrift.MAP, 5); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:Requests: ", p), err) } if err := oprot.WriteMapBegin(thrift.I32, thrift.STRING, len(p.Requests)); err != nil { return thrift.PrependError("error writing map begin: ", err) } for k, v := range p.Requests { if err := oprot.WriteI32(int32(k)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } if err := oprot.WriteString(string(v)); err != nil { return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } } if err := oprot.WriteMapEnd(); err != nil { return thrift.PrependError("error writing map end: ", err) } if err := oprot.WriteFieldEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T write field end error 5:Requests: ", p), err) } } return nil } func (p *TestingUnions) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("TestingUnions(%+v)", *p) } type AwesomeException struct { // ID is a unique identifier for an awesome exception. ID ID // Reason contains the error message. Reason string // Deprecated: use something else Depr bool } func NewAwesomeException() *AwesomeException { return &AwesomeException{} } func (p *AwesomeException) GetID() ID { return p.ID } func (p *AwesomeException) GetReason() string { return p.Reason } func (p *AwesomeException) GetDepr() bool { return p.Depr } func (p *AwesomeException) Read(iprot thrift.TProtocol) error { if _, err := iprot.ReadStructBegin(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) } for { _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin() if err != nil { return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err) } if fieldTypeId == thrift.STOP { break } switch fieldId { case 1: if v, err := iprot.ReadI64(); err != nil { return thrift.PrependError("error reading field 1: ", err) } else { temp := ID(v) p.ID = temp } case 2: if v, err := iprot.ReadString(); err != nil { return thrift.PrependError("error reading field 2: ", err) } else { p.Reason = v } case 3: if v, err := iprot.ReadBool(); err != nil { return thrift.PrependError("error reading field 3: ", err) } else { p.Depr = v } default: if err := iprot.Skip(fieldTypeId); err != nil { return err } } if err := iprot.ReadFieldEnd(); err != nil { return err } } if err := iprot.ReadStructEnd(); err != nil { return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } return nil } func (p *AwesomeException) Write(oprot thrift.TProtocol) error { if err := oprot.WriteStructBegin("AwesomeException"); err != nil { return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } if err := frugal.WriteI64(oprot, int64(p.ID), "ID", 1); err != nil { return thrift.PrependError(fmt.Sprintf("%T::ID:1 ", p), err) } if err := frugal.WriteString(oprot, p.Reason, "Reason", 2); err != nil { return thrift.PrependError(fmt.Sprintf("%T::Reason:2 ", p), err) } if err := frugal.WriteBool(oprot, p.Depr, "depr", 3); err != nil { return thrift.PrependError(fmt.Sprintf("%T::depr:3 ", p), err) } if err := oprot.WriteFieldStop(); err != nil { return thrift.PrependError("write field stop error: ", err) } if err := oprot.WriteStructEnd(); err != nil { return thrift.PrependError("write struct stop error: ", err) } return nil } func (p *AwesomeException) String() string { if p == nil { return "<nil>" } return fmt.Sprintf("AwesomeException(%+v)", *p) } func (p *AwesomeException) Error() string { return p.String() }
{ return &EventWrapper{} }
p1.rs
use file_reader; const INPUT_FILENAME: &str = "input.txt"; fn
() { let input_str = match file_reader::file_to_vec(INPUT_FILENAME) { Err(_) => { println!("Couldn't turn file into vec!"); return; }, Ok(v) => v, }; let mut input_str_f: Vec<String> = Vec::new(); let mut input_idx = 0; for line in input_str.into_iter() { if input_str_f.len() == input_idx { input_str_f.push(line); } else if line == "" { input_idx += 1; } else { input_str_f[input_idx].push_str(&line); } } let input: Vec<Vec<char>> = input_str_f.into_iter().map(process_input).collect(); let result = input.into_iter().fold(0, |acc, x| acc + x.len()); println!("{:?}", result); } fn process_input(input: String) -> Vec<char> { let mut input_vec: Vec<char> = input.chars().collect(); input_vec.sort(); input_vec.dedup(); input_vec }
main
server.js
const express = require('express'); const morgan = require('morgan'); const fs = require('fs'); const historyApiFallback = require('connect-history-api-fallback'); const mongoose = require('mongoose'); const path = require('path'); const webpack = require('webpack'); const webpackDevMiddleware = require('webpack-dev-middleware'); const webpackHotMiddleware = require('webpack-hot-middleware'); const config = require('../config/config'); const webpackConfig = require('../webpack.config'); const isDev = process.env.NODE_ENV !== 'production'; const port = process.env.PORT || 8080; // Configuration // ================================================================================================ // Set up Mongoose mongoose.connect(isDev ? config.db_dev : config.db); mongoose.Promise = global.Promise; const app = express(); app.use(express.urlencoded({ extended: true })); app.use(express.json()); app.use(morgan('dev')); // API routes require('./routes')(app); if (isDev) { const compiler = webpack(webpackConfig); app.use(historyApiFallback({ verbose: false })); app.use(webpackDevMiddleware(compiler, { publicPath: webpackConfig.output.publicPath, contentBase: path.resolve(__dirname, '../client/public'), stats: { colors: true, hash: false, timings: true, chunks: false, chunkModules: false, modules: false } })); app.use(webpackHotMiddleware(compiler)); app.use(express.static(path.resolve(__dirname, '../dist'))); } else { app.use(express.static(path.resolve(__dirname, '../dist'))); app.get('*', function (req, res) { res.sendFile(path.resolve(__dirname, '../dist/index.html')); res.end(); }); } var cors = require('cors'); app.use(cors())
}) app.listen(port, '0.0.0.0', (err) => { //app.listen(port, 'localhost', (err) => { if (err) { console.log(err); } console.info('>>> 🌎 Open localhost:%s/ in your browser.', port); }); module.exports = app;
app.get('/products/:id', function (req, res, next) { res.json({msg: 'This is CORS-enabled for all origins!'})
test_command_input.py
import os import pytest def test_wrong_select_db_index(cli): cli.sendline("select 1") cli.expect(["OK", "127.0.0.1"]) cli.sendline("select 128") cli.expect(["DB index is out of range", "127.0.0.1:6379[1]>"]) if int(os.environ["REDIS_VERSION"]) > 5: text = "value is not an integer or out of range" else: text = "invalid DB index" cli.sendline("select abc") cli.expect([text, "127.0.0.1:6379[1]>"]) cli.sendline("select 15") cli.expect("OK") def test_set_command_with_shash(clean_redis, cli): cli.sendline("set a \\hello\\") # legal redis command cli.expect("OK") cli.sendline("get a") cli.expect(r"hello") def test_enter_key_binding(clean_redis, cli): cli.send("set") cli.expect("set") cli.send("\033[B") # down cli.sendline() # enter cli.sendline(" a 'hello'") cli.expect("OK") cli.sendline("get a") cli.expect(r"hello") @pytest.mark.skipif("int(os.environ['REDIS_VERSION']) < 6") def test_auth_hidden_password_with_username(clean_redis, cli): cli.send("auth default hello-world") cli.expect("default") cli.expect(r"\*{11}") @pytest.mark.skipif("int(os.environ['REDIS_VERSION']) > 5") def test_auth_hidden_password(clean_redis, cli):
def test_hello_command_is_not_supported(cli): cli.sendline("hello 3") cli.expect("IRedis currently not support RESP3") def test_abort_reading_connection(cli): cli.sendline("blpop mylist 30") cli.send(chr(3)) cli.expect( r"KeyboardInterrupt received! User canceled reading response!", timeout=10 ) cli.sendline("set foo bar") cli.expect("OK") cli.sendline("get foo") cli.expect("bar")
cli.send("auth hello-world") cli.expect("auth") cli.expect(r"\*{11}")
disk_errors_test.go
// Copyright 2021 The Chromium OS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. package hardware import ( "strings" "testing" "github.com/google/go-cmp/cmp" ) func TestDiskErrorLines(t *testing.T) { splitLines := func(text string) []string { return strings.Split(text, "\n") } for _, tc := range []struct { name string lines []string
{ name: "ATA errors", lines: splitLines(`[ 49.135097] ata1.00: exception Emask 0x0 SAct 0x10000000 SErr 0x0 action 0x6 frozen [ 49.135112] ata1.00: failed command: READ FPDMA QUEUED [ 49.135126] ata1.00: cmd 60/40:e0:f0:f1:b5/00:00:00:00:00/40 tag 28 ncq dma 32768 in [ 49.135126] res 40/00:00:00:00:00/00:00:00:00:00/00 Emask 0x4 (timeout) [ 49.135133] ata1.00: status: { DRDY } [ 49.135142] ata1: hard resetting link [ 49.445043] ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) [ 49.448140] ata1.00: configured for UDMA/133 [ 49.448173] ata1.00: device reported invalid CHS sector 0 [ 49.448196] ata1: EH complete`), want: splitLines(`[ 49.135097] ata1.00: exception Emask 0x0 SAct 0x10000000 SErr 0x0 action 0x6 frozen [ 49.135142] ata1: hard resetting link`), }, { name: "SCSI errors", lines: splitLines(`[ 241.378165] sd 0:0:0:0: [sda] 30031872 512-byte logical blocks: (15.4 GB/14.3 GiB) [ 241.378905] sd 0:0:0:0: [sda] Write Protect is off [ 241.378910] sd 0:0:0:0: [sda] Mode Sense: 43 00 00 00 [ 241.379429] sd 0:0:0:0: [sda] Write cache: disabled, read cache: enabled, doesn't support DPO or FUA [ 241.414705] sd 0:0:0:0: [sda] Attached SCSI removable disk [ 241.614066] sd 0:0:0:0: [sda] tag#0 FAILED Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK [ 241.614076] sd 0:0:0:0: [sda] tag#0 CDB: Read(10) 28 00 00 05 d0 80 00 00 08 00 [ 241.614080] print_req_error: I/O error, dev sda, sector 381056 [ 241.654058] sd 0:0:0:0: [sda] tag#0 FAILED Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK [ 241.654068] sd 0:0:0:0: [sda] tag#0 CDB: Read(10) 28 00 00 01 50 48 00 00 30 00`), want: splitLines(`[ 241.614066] sd 0:0:0:0: [sda] tag#0 FAILED Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK [ 241.654058] sd 0:0:0:0: [sda] tag#0 FAILED Result: hostbyte=DID_ERROR driverbyte=DRIVER_OK`), }, // Block device errors should be ignored because some of them are // produced for loopback devices, in which case errors are harmless. { name: "Block device errors (blk_update_request)", lines: splitLines(`[ 16.076930] blk_update_request: I/O error, dev loop9, sector 0 [ 16.076941] blk_update_request: I/O error, dev loop9, sector 0`), want: nil, }, { name: "Block device errors (print_req_error)", lines: splitLines(`[ 112.866869] print_req_error: I/O error, dev loop9, sector 0 [ 112.866888] print_req_error: I/O error, dev loop9, sector 0 [ 112.866893] Buffer I/O error on dev loop9, logical block 0, async page read`), want: nil, }, } { got := diskErrorLines(tc.lines) if diff := cmp.Diff(got, tc.want); diff != "" { t.Errorf("%s: mismatch (-got +want):\n%s", tc.name, diff) } } }
want []string }{
v1_rolling_update_stateful_set_strategy.py
# coding: utf-8 """ Kubernetes No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) OpenAPI spec version: v1.14.4 Generated by: https://github.com/swagger-api/swagger-codegen.git """ from pprint import pformat from six import iteritems import re class V1RollingUpdateStatefulSetStrategy(object): """ NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'partition': 'int' } attribute_map = { 'partition': 'partition' } def __init__(self, partition=None): """ V1RollingUpdateStatefulSetStrategy - a model defined in Swagger """ self._partition = None self.discriminator = None if partition is not None: self.partition = partition @property def partition(self): """ Gets the partition of this V1RollingUpdateStatefulSetStrategy. Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. :return: The partition of this V1RollingUpdateStatefulSetStrategy. :rtype: int """ return self._partition @partition.setter def partition(self, partition): """ Sets the partition of this V1RollingUpdateStatefulSetStrategy. Partition indicates the ordinal at which the StatefulSet should be partitioned. Default value is 0. :param partition: The partition of this V1RollingUpdateStatefulSetStrategy. :type: int """ self._partition = partition def to_dict(self): """ Returns the model properties as a dict """ result = {} for attr, _ in iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value return result def to_str(self): """ Returns the string representation of the model """ return pformat(self.to_dict()) def __repr__(self): """ For `print` and `pprint` """ return self.to_str() def __eq__(self, other): """ Returns true if both objects are equal """ if not isinstance(other, V1RollingUpdateStatefulSetStrategy): return False return self.__dict__ == other.__dict__
def __ne__(self, other): """ Returns true if both objects are not equal """ return not self == other
test_request_history.py
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from test.base import BaseTest from activitystreams import parse as as_parser from dino.validation import request class RequestHistoryTest(BaseTest): def setUp(self): super(RequestHistoryTest, self).setUp() self.create_channel_and_room() def test_history(self): act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0]) def test_history_no_target_id(self): act = self.activity_for_history(skip={'target_id'}) response_data = request.on_history(as_parser(act)) self.assertEqual(False, response_data[0]) def test_history_not_allowed_not_owner_not_in_room_age(self): self.leave_room() self.remove_owner() self.remove_owner_channel() self.set_acl_single('history|age', str(int(BaseTest.AGE) + 10) + ':') act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(False, response_data[0]) def test_history_not_allowed_not_owner_in_room(self): self.join_room() self.remove_owner() self.remove_owner_channel() self.set_acl_single('history|age', str(int(BaseTest.AGE) + 10) + ':') act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(False, response_data[0]) def test_history_allowed_owner_not_in_room(self): self.leave_room() self.set_owner() self.set_acl_single('history|sameroom', '') act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0]) def test_history_not_allowed_not_owner_not_in_room_sameroom(self): self.leave_room() self.remove_owner() self.remove_owner_channel() self.set_acl_single('history|sameroom', '') act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(False, response_data[0]) def test_history_not_allowed_owner_in_room(self): self.join_room() self.set_owner() self.set_acl_single('history|age', str(int(BaseTest.AGE) + 10) + ':') act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0]) def test_history_allowed_not_owner_not_in_room(self): self.leave_room() self.remove_owner() self.remove_owner_channel() act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0]) def test_history_allowed_not_owner_in_room(self): self.join_room() self.remove_owner() self.remove_owner_channel() act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0]) def test_history_allowed_owner_in_room(self):
self.join_room() self.set_owner() act = self.activity_for_history() response_data = request.on_history(as_parser(act)) self.assertEqual(True, response_data[0])
glmt_test.go
package glmt import ( "context" "reflect" "regexp" "testing" "gitlab.com/gitlab-merge-tool/glmt/internal/config" "gitlab.com/gitlab-merge-tool/glmt/internal/gitlab" hooksi "gitlab.com/gitlab-merge-tool/glmt/internal/hooks/impl" "gitlab.com/gitlab-merge-tool/glmt/internal/team" teami "gitlab.com/gitlab-merge-tool/glmt/internal/team/impl" ) func TestRemoteParse(t *testing.T) { r := "https://github.com/hummerd/client_golang.git" p, err := projectFromRemote(r) if err != nil { t.Fatalf("failed to parse remote %s: %v", r, err) } if p != "hummerd/client_golang" { t.Fatalf("wrong project: %s", p) } r = "[email protected]:hummerd/client_golang.git" p, err = projectFromRemote(r) if err != nil { t.Fatalf("failed to parse remote %s: %v", r, err) } if p != "hummerd/client_golang" { t.Fatalf("wrong project: %s", p) } r = "[email protected]:hummerd/client_golang" p, err = projectFromRemote(r) if err != nil { t.Fatalf("failed to parse remote %s: %v", r, err) } if p != "hummerd/client_golang" { t.Fatalf("wrong project: %s", p) } } func TestTextArgs(t *testing.T) { expTa := map[string]string{ TmpVarProjectName: "prj1", TmpVarBranchName: "feature/TASK-123/some-description", TmpVarTargetBranchName: "develop", TmpVarGitlabMentions: "@test", TmpVarRemote: "origin", TmpVarUsername: "xxx", "Task": "TASK-123", "TaskType": "feature", "BranchDescription": "some-description", } params := CreateMRParams{ TargetBranch: expTa["TargetBranchName"], BranchRegexp: regexp.MustCompile(`(?P<TaskType>.*)/(?P<Task>.*)/(?P<BranchDescription>.*)`), } members := []*team.Member{{ Username: "test", }} ta := getTextArgs(expTa["BranchName"], expTa["ProjectName"], "origin", "xxx", params, members) if !reflect.DeepEqual(expTa, ta) { t.Fatalf("expected ta: %+v, got %+v", expTa, ta) } } func
(t *testing.T) { gs := &gitStub{ r: "https://github.com/hummerd/client_golang.git", b: "feature/TASK-123/add-some-feature", } cp := CreateMRParams{ DescriptionTemplate: "Merge {{.TaskType}} {{.Task}} \"{{humanizeText .BranchDescription}}\" into {{.TargetBranchName}}", TitleTemplate: "{{.Task}} {{humanizeText .BranchDescription}}", RemoveBranch: true, Squash: true, TargetBranch: "develop", LabelVars: []string{"TaskType"}, BranchRegexp: regexp.MustCompile("(?P<TaskType>.*)/(?P<Task>.*)/(?P<BranchDescription>.*)"), } good := false gls := &gitlabStub{ f: func(method string, arg interface{}) { if method == "CreateMR" { good = true exp := gitlab.CreateMRRequest{ Description: "Merge feature TASK-123 \"Add some feature\" into develop", Title: "TASK-123 Add some feature", Project: "hummerd/client_golang", SourceBranch: gs.b, TargetBranch: cp.TargetBranch, RemoveSourceBranch: cp.RemoveBranch, Squash: cp.Squash, AssigneeID: 123, Labels: "feature", } if !reflect.DeepEqual(exp, arg) { t.Fatalf("expected create request: %+v, got %+v", exp, arg) } } }, } ts, _ := teami.NewTeamSource("") hs := hooksi.NewHooks(config.Hooks{}, nil, nil) c := Core{ git: gs, gitLab: gls, teamSource: ts, hooks: hs, } mr, err := c.CreateMR(context.Background(), cp) if err != nil { t.Fatal("error creating MR", err) } if mr.ID != 123 { t.Fatal("wrong MR id", mr.ID) } if !good { t.Fatal("no call to CreateMR") } } type gitStub struct { r string b string } func (gs *gitStub) Remote() (string, error) { return gs.r, nil } func (gs *gitStub) CurrentBranch() (string, error) { return gs.b, nil } type gitlabCallback func(string, interface{}) type gitlabStub struct { f gitlabCallback } func (gls *gitlabStub) CreateMR(ctx context.Context, req gitlab.CreateMRRequest) (gitlab.CreateMRResponse, error) { gls.f("CreateMR", req) return gitlab.CreateMRResponse{ ID: 123, }, nil } func (gls *gitlabStub) CurrentUser(ctx context.Context) (gitlab.UserResponse, error) { gls.f("CurrentUser", nil) return gitlab.UserResponse{ ID: 123, }, nil }
TestCreateMR
cross_reference_crud.py
from sqlalchemy.orm import Session from datetime import datetime from fastapi import HTTPException from fastapi import status from fastapi.encoders import jsonable_encoder from literature.schemas import CrossReferenceSchema from literature.schemas import CrossReferenceSchemaUpdate from literature.models import CrossReferenceModel from literature.models import ReferenceModel from literature.models import ResourceModel from literature.models import ResourceDescriptorModel from literature.crud.reference_resource import create_obj, add_reference_resource def create(db: Session, cross_reference: CrossReferenceSchema) -> str: cross_reference_data = jsonable_encoder(cross_reference) if db.query(CrossReferenceModel).filter(CrossReferenceModel.curie == cross_reference_data['curie']).first(): raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"CrossReference with curie {cross_reference_data['curie']} already exists") db_obj = create_obj(db, CrossReferenceModel, cross_reference_data) db.add(db_obj) db.commit() return "created" def
(db: Session, curie: str) -> None: cross_reference = db.query(CrossReferenceModel).filter(CrossReferenceModel.curie == curie).first() if not cross_reference: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Cross Reference with curie {curie} not found") db.delete(cross_reference) db.commit() return None def patch(db: Session, curie: str, cross_reference_update: CrossReferenceSchemaUpdate) -> dict: cross_reference_data = jsonable_encoder(cross_reference_update) cross_reference_db_obj = db.query(CrossReferenceModel).filter(CrossReferenceModel.curie == curie).first() if not cross_reference_db_obj: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Cross Reference with curie {curie} not found") add_reference_resource(db, cross_reference_db_obj, cross_reference_update, non_fatal=True) for field, value in cross_reference_data.items(): setattr(cross_reference_db_obj, field, value) cross_reference_db_obj.date_updated = datetime.utcnow() db.commit() return {"message": "updated"} def show(db: Session, curie: str, indirect=True) -> dict: cross_reference = db.query(CrossReferenceModel).filter(CrossReferenceModel.curie == curie).first() if not cross_reference: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"CrossReference with the curie {curie} is not available") cross_reference_data = jsonable_encoder(cross_reference) if cross_reference_data['resource_id']: cross_reference_data['resource_curie'] = db.query(ResourceModel.curie).filter(ResourceModel.resource_id == cross_reference_data['resource_id']).first().curie del cross_reference_data['resource_id'] if cross_reference_data['reference_id']: cross_reference_data['reference_curie'] = db.query(ReferenceModel.curie).filter(ReferenceModel.reference_id == cross_reference_data['reference_id']).first().curie del cross_reference_data['reference_id'] author_ids = [] editor_ids = [] if not indirect: for author in cross_reference.authors: author_ids.append(author.author_id) for editor in cross_reference.editors: editor_ids.append(editor.editor_id) cross_reference_data['author_ids'] = author_ids cross_reference_data['editor_ids'] = editor_ids [db_prefix, local_id] = curie.split(":", 1) resource_descriptor = db.query(ResourceDescriptorModel).filter(ResourceDescriptorModel.db_prefix == db_prefix).first() if resource_descriptor: default_url = resource_descriptor.default_url.replace("[%s]", local_id) cross_reference_data['url'] = default_url if cross_reference_data['pages']: pages_data = [] for cr_page in cross_reference_data['pages']: page_url = "" for rd_page in resource_descriptor.pages: if rd_page.name == cr_page: page_url = rd_page.url break pages_data.append({"name": cr_page, "url": page_url.replace("[%s]", local_id)}) cross_reference_data['pages'] = pages_data elif cross_reference_data['pages']: pages_data = [] for cr_page in cross_reference_data['pages']: pages_data.append({"name": cr_page}) cross_reference_data['pages'] = pages_data return cross_reference_data def show_changesets(db: Session, curie: str): cross_reference = db.query(CrossReferenceModel).filter(CrossReferenceModel.curie == curie).first() if not cross_reference: raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Cross Reference with curie {curie} is not available") history = [] for version in cross_reference.versions: tx = version.transaction history.append({'transaction': {'id': tx.id, 'issued_at': tx.issued_at, 'user_id': tx.user_id}, 'changeset': version.changeset}) return history
destroy
index.ts
export { default as valudateNotNull } from './validateNotNull.util';
export { default as runPromise } from './runPromise.util';
page-state.test.ts
/* eslint-disable functional/functional-parameters */ /* eslint-disable functional/no-expression-statement */ import { getPageState } from "."; describe("getPageState", () => { test('returns "body" focus selector by default', () => { const state = getPageState();
y: 0, }); }); });
expect(state).toEqual({ focusSelector: "body", x: 0,
boneTreeItemComponent.tsx
import { IExplorerExtensibilityGroup } from "babylonjs/Debug/debugLayer"; import { faBone } from "@fortawesome/free-solid-svg-icons"; import { TreeItemLabelComponent } from "../treeItemLabelComponent"; import { ExtensionsComponent } from "../extensionsComponent"; import * as React from "react"; import { Bone } from "babylonjs/Bones/bone"; interface IBoneTreeItemComponenttProps { bone: Bone; extensibilityGroups?: IExplorerExtensibilityGroup[]; onClick: () => void; } export class BoneTreeItemComponent extends React.Component<IBoneTreeItemComponenttProps> { constructor(props: IBoneTreeItemComponenttProps) { super(props); }
return ( <div className="skeletonTools"> <TreeItemLabelComponent label={bone.name || "no name"} onClick={() => this.props.onClick()} icon={faBone} color="lightgray" /> {<ExtensionsComponent target={bone} extensibilityGroups={this.props.extensibilityGroups} />} </div> ); } }
render() { const bone = this.props.bone;
firewall_rule.py
# VMware vCloud Director Python SDK # Copyright (c) 2014-2019 VMware, Inc. All Rights Reserved. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from pyvcloud.vcd.client import create_element from pyvcloud.vcd.client import EntityType from pyvcloud.vcd.exceptions import InvalidParameterException from pyvcloud.vcd.gateway import Gateway from pyvcloud.vcd.gateway_services import GatewayServices from pyvcloud.vcd.network_url_constants import FIREWALL_RULE_URL_TEMPLATE from pyvcloud.vcd.network_url_constants import FIREWALL_RULES_URL_TEMPLATE from pyvcloud.vcd.network_url_constants import FIREWALL_URL_TEMPLATE class FirewallRule(GatewayServices): __SOURCE = 'source' __DESTINATION = 'destination' __GROUP_OBJECT_LIST = [ 'securitygroup', 'ipset', 'virtualmachine', 'network' ] __VNIC_GROUP_LIST = ['gatewayinterface'] __APPLICATION = 'application' __SERVICE = 'service' __PROTOCOL_LIST = ['tcp', 'udp', 'icmp', 'any'] def _build_self_href(self, rule_id): rule_href = ( self.network_url + FIREWALL_RULE_URL_TEMPLATE).format(rule_id) self.href = rule_href def _extract_id(self, rule_href): rule_id_index = rule_href.index(FIREWALL_RULES_URL_TEMPLATE) + \ len(FIREWALL_RULES_URL_TEMPLATE) + 1 return rule_href[rule_id_index:] def __config_url(self): config_index = self.href.index(FIREWALL_URL_TEMPLATE) return self.href[:config_index] + FIREWALL_URL_TEMPLATE def _reload(self): """Reloads the resource representation of the Firewall rule.""" self.resource = \ self.client.get_resource(self.href) def delete(self): """Delete a Firewall rule from gateway.""" self._get_resource() return self.client.delete_resource(self.href) def edit(self, source_values=None, destination_values=None, services=None, new_name=None): """Edit a Firewall rule. :param list source_values: list of source values. e.g., [value:value_type] :param list destination_values: list of destination values. e.g., [value:value_type] :param list services: protocol to port mapping. e.g., [{'tcp' : {'any' : any}}] :param str new_name: new name of the firewall rule. """ self._get_resource() self.validate_types(source_values, FirewallRule.__SOURCE) self.validate_types(destination_values, FirewallRule.__DESTINATION) firewall_rule_temp = self.resource if source_values: if not hasattr(firewall_rule_temp, FirewallRule.__SOURCE): firewall_rule_temp.append( create_element(FirewallRule.__SOURCE)) if not hasattr(firewall_rule_temp.source, 'exclude'): firewall_rule_temp.source.append( create_element('exclude', False)) self._populate_objects_info(firewall_rule_temp, source_values, FirewallRule.__SOURCE) if destination_values: if not hasattr(firewall_rule_temp, FirewallRule.__DESTINATION): firewall_rule_temp.append( create_element(FirewallRule.__DESTINATION)) if not hasattr(firewall_rule_temp.destination, 'exclude'): firewall_rule_temp.destination.append( create_element('exclude', False)) self._populate_objects_info(firewall_rule_temp, destination_values, FirewallRule.__DESTINATION) if services: if not hasattr(firewall_rule_temp, FirewallRule.__APPLICATION): firewall_rule_temp.append( create_element(FirewallRule.__APPLICATION)) self._populate_services(firewall_rule_temp, services) if new_name: firewall_rule_temp.name = new_name self.client.put_resource(self.href, firewall_rule_temp, EntityType.DEFAULT_CONTENT_TYPE.value) def _populate_services(self, firewall_rule_temp, services): """Populates service elements. :param firewall_rule_temp: Firewall rule :param [] services: protocol to port mapping. e.g., [{'tcp' : {'any' : any}}] """ if services: for service in services: protocol = [k for k in service.keys()][0] if protocol not in FirewallRule.__PROTOCOL_LIST: valid_protocols = ', '.join(FirewallRule.__PROTOCOL_LIST) raise InvalidParameterException( protocol + " is not valid. It should be from " + valid_protocols) value = service.get(protocol) source_port = [port for port in value.keys()][0] destination_port = value.get(source_port) self.__populate_protocol_elements(firewall_rule_temp, protocol, source_port, destination_port) def __populate_protocol_elements(self, firewall_rule_temp, protocol, source_port, destination_port): """Populate protocol elements. It mutates the firewall rule object. :param firewall_rule_temp: Firewall rule obj :param protocol: protocol :param source_port: source port :param destination_port: destination port """ application_tag = firewall_rule_temp.application service_tag = create_element('service') service_tag.append(create_element('protocol', protocol)) service_tag.append(create_element('port', destination_port)) service_tag.append(create_element('sourcePort', source_port)) if protocol == 'icmp': service_tag.append(create_element('icmpType', 'any')) application_tag.append(service_tag) def _populate_objects_info(self, firewall_rule_temp, values, type): """It will mutate firewall_rule_temp. :param firewall_rule_temp: Firewall rule object resource :param list values: list of values :param str type: type. e.g., source, destination """ for value in values: values_arr = value.split(':') object_type = values_arr[1] object = values_arr[0] if type == FirewallRule.__SOURCE: firewall_rule_temp.source.append( self._get_group_element(type, object_type, object)) if type == FirewallRule.__DESTINATION: firewall_rule_temp.destination.append( self._get_group_element(type, object_type, object)) def _get_group_element(self, type, object_type, value): """Get group element base upon the type and object type. :param str type: It can be source/destination :param str object_type: Possible values for this would be 'gatewayinterface','virtualmachine','network', 'ipset', 'securitygroup', 'ip' :param str value: value :return: group objectified element :rtype: :rtype: lxml.objectify.ObjectifiedElement """ if object_type == 'ip': return create_element('ipAddress', value) if object_type in FirewallRule.__GROUP_OBJECT_LIST: return self.__find_element(type, object_type, value, 'groupingObjectId') elif object_type in FirewallRule.__VNIC_GROUP_LIST: return self.__find_element(type, object_type, value, 'vnicGroupId') def __find_element(self, type, object_type, value, group_type): """Find element in the properties using group type. :param str type: It can be source/destination :param dict object_type: object types :param str value: value :param str group_type: group type. e.g., groupingObjectId """ gateway_res = Gateway(self.client, resource=self.parent) object_list = gateway_res.list_firewall_objects(type, object_type) for object in object_list: if object.get('name') == value: properties = object.get('prop') for prop in properties: if prop.get('name') == group_type: return create_element(group_type, prop.get('value')) def validate_types(self, source_types, type): """Validate input param for valid type. :param list source_types: list of value:value_type. e.g., ExtNw:gatewayinterface :param str type: It can be source/destination :raise: InvalidParameterException: exception if input param is not valid. """ if source_types: valid_type_list = [ 'gatewayinterface', 'virtualmachine', 'network', 'ipset', 'securitygroup', 'ip' ] for source_type in source_types: if source_type.lower() == 'any':
source_type_arr = source_type.split(':') if len(source_type_arr) <= 1: raise InvalidParameterException( type + " type should be in the format of " "value:value_type. for ex: " "ExtNw:gatewayinterface") valid_type = source_type_arr[1] if valid_type not in valid_type_list: valid_type_list_str = ','.join(valid_type_list) raise InvalidParameterException( valid_type + " param is not valid. It should be " "from " + valid_type_list_str) def enable_disable_firewall_rule(self, is_enabled): """Enabled disabled firewall rule from gateway. :param bool is_enabled: flag to enable/disable the firewall rule. """ current_firewall_status = self._get_resource().enabled if is_enabled == current_firewall_status: return if is_enabled: self._get_resource().enabled = True return self.client.put_resource( self.href, self._get_resource(), EntityType.DEFAULT_CONTENT_TYPE.value) else: self._get_resource().enabled = False return self.client.put_resource( self.href, self._get_resource(), EntityType.DEFAULT_CONTENT_TYPE.value) def info_firewall_rule(self): """Get the details of firewall rule. return: Dictionary having firewall rule details. e.g. {'Id': 196609, 'Name': 'Test rule', 'Rule type':'user', 'Enabled':'True','Logging enabled':'True','Action':'Accept'} :rtype: Dictionary """ firewall_rule_info = {} resource = self._get_resource() firewall_rule_info['Id'] = resource.id firewall_rule_info['Name'] = resource.name firewall_rule_info['Rule type'] = resource.ruleType firewall_rule_info['Enabled'] = resource.enabled firewall_rule_info['Logging enabled'] = resource.loggingEnabled firewall_rule_info['Action'] = resource.action return firewall_rule_info def list_firewall_rule_source_destination(self, type): """Get the list of firewall rule source/destination. :param str type: It can be source/destination return: dict of firewall rule's source/destination details. e.g. {'exclude':'True','ipAddress':['10.112.12.12','10.232.1.2'], 'vnicGroupId':['vse','external','internal','vnic-0'], 'groupingObjectId':['1f0aab71-6d11-4567-994e-2c090fea7350:ipset', 'urn:vcloud:network:3ed60402-904f-410d-913c-6da77b43a257:'] } :rtype: dict """ resource = self._get_resource() firewall_rule_source_destination = {} if hasattr(resource, type): if hasattr(resource[type], 'exclude'): firewall_rule_source_destination['exclude'] = resource[ type].exclude if hasattr(resource[type], 'vnicGroupId'): firewall_rule_source_destination['vnicGroupId'] = [ vnicGroupId for vnicGroupId in resource[type].vnicGroupId ] if hasattr(resource[type], 'ipAddress'): firewall_rule_source_destination['ipAddress'] = [ ipAddress for ipAddress in resource[type].ipAddress ] if hasattr(resource[type], 'groupingObjectId'): firewall_rule_source_destination['groupingObjectId'] = [ groupingObjectId for groupingObjectId in resource[type].groupingObjectId ] return firewall_rule_source_destination def _build_firewall_rules_href(self): return self.network_url + FIREWALL_URL_TEMPLATE def update_firewall_rule_sequence(self, index): """Change firewall rule's sequence of gateway. :param int index: new sequence index of firewall rule. """ index = int(index) gateway_res = Gateway(self.client, resource=self.parent) firewall_rule = gateway_res.get_firewall_rules() resource = self._get_resource() for rule in firewall_rule.firewallRules.firewallRule: if rule.id == resource.id: firewall_rule.firewallRules.remove(rule) firewall_rule.firewallRules.insert(index, rule) break return self.client.put_resource(self._build_firewall_rules_href(), firewall_rule, EntityType.DEFAULT_CONTENT_TYPE.value) def delete_firewall_rule_source_destination(self, value, type): """Delete firewall rule's source/destination value of gateway. It will delete all source/destination value of given value. :param str value: value to remove from source/destination. :param str type: It can be source/destination """ resource = self._get_resource() if hasattr(resource, type): for object in resource[type].iter(): if object == value: resource[type].remove(object) return self.client.put_resource(self.href, resource, EntityType.DEFAULT_CONTENT_TYPE.value)
continue
utils.py
import os import errno import tensorflow as tf from keras import backend as K def safe_mkdir(dir_to_make: str) -> None: ''' Attempts to make a directory following the Pythonic EAFP strategy which prevents race conditions. :param dir_to_make: The directory path to attempt to make. :return: None ''' try: os.makedirs(dir_to_make) except OSError as e: if e.errno != errno.EEXIST: print('ERROR: Unable to create directory: {}'.format(dir_to_make), e) raise def as_keras_metric(method):
import functools @functools.wraps(method) def wrapper(self, args, **kwargs): """ Wrapper for turning tensorflow metrics into keras metrics """ value, update_op = method(self, args, **kwargs) K.get_session().run(tf.local_variables_initializer()) with tf.control_dependencies([update_op]): value = tf.identity(value) return value return wrapper
commit_announcer.py
# Copyright (C) 2013 Google Inc. All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import logging import re import threading import time from webkitpy.common.checkout.scm.git import Git from webkitpy.common.system.executive import ScriptError from webkitpy.thirdparty.irc.ircbot import SingleServerIRCBot _log = logging.getLogger(__name__) SERVER = "irc.freenode.net" PORT = 6667 CHANNEL = "#blink" NICKNAME = "commit-bot" PULL_TIMEOUT_SECONDS = 60 * 5 UPDATE_WAIT_SECONDS = 10 RETRY_ATTEMPTS = 8 class CommitAnnouncer(SingleServerIRCBot): _commit_detail_format = "%H\n%ae\n%s\n%b" # commit-sha1, author email, subject, body def __init__(self, tool, announce_path, irc_password): SingleServerIRCBot.__init__(self, [(SERVER, PORT, irc_password)], NICKNAME, NICKNAME) self.announce_path = announce_path self.git = Git(cwd=tool.scm().checkout_root, filesystem=tool.filesystem, executive=tool.executive) self.commands = { 'help': self.help, 'ping': self.ping, 'quit': self.stop, } self.last_commit = None def start(self): if not self._update(): return self.last_commit = self.git.latest_git_commit() SingleServerIRCBot.start(self) def post_new_commits(self): if not self.connection.is_connected(): return if not self._update(force_clean=True): self.stop("Failed to update repository!") return new_commits = self.git.git_commits_since(self.last_commit) if not new_commits: return self.last_commit = new_commits[-1] for commit in new_commits: if not self._should_announce_commit(commit): continue commit_detail = self._commit_detail(commit) if commit_detail: _log.info('%s Posting commit %s', self._time(), commit) _log.info('%s Posted message: %s', self._time(), repr(commit_detail)) self._post(commit_detail) else: _log.error('Malformed commit log for %s', commit) # Bot commands. def help(self): self._post('Commands available: %s' % ' '.join(self.commands.keys())) def ping(self): self._post('Pong.') def stop(self, message=""): self.connection.execute_delayed(0, lambda: self.die(message)) # IRC event handlers. Methods' arguments are determined by superclass # and some arguments maybe unused - pylint: disable=unused-argument def on_nicknameinuse(self, connection, event): connection.nick('%s_' % connection.get_nickname()) def on_welcome(self, connection, event): connection.join(CHANNEL) def on_pubmsg(self, connection, event): message = event.arguments()[0] command = self._message_command(message) if command: command() def _update(self, force_clean=False): if not self.git.is_cleanly_tracking_remote_master(): if not force_clean: confirm = raw_input('This repository has local changes, continue? (uncommitted changes will be lost) y/n: ') if not confirm.lower() == 'y': return False try: self.git.ensure_cleanly_tracking_remote_master() except ScriptError as e: _log.error('Failed to clean repository: %s', e) return False attempts = 1 while attempts <= RETRY_ATTEMPTS: if attempts > 1: # User may have sent a keyboard interrupt during the wait. if not self.connection.is_connected(): return False wait = int(UPDATE_WAIT_SECONDS) << (attempts - 1) if wait < 120: _log.info('Waiting %s seconds', wait) else: _log.info('Waiting %s minutes', wait / 60) time.sleep(wait) _log.info('Pull attempt %s out of %s', attempts, RETRY_ATTEMPTS) try: self.git.pull(timeout_seconds=PULL_TIMEOUT_SECONDS) return True except ScriptError as e: _log.error('Error pulling from server: %s', e) _log.error('Output: %s', e.output) attempts += 1 _log.error('Exceeded pull attempts') _log.error('Aborting at time: %s', self._time()) return False def _time(self): return time.strftime('[%x %X %Z]', time.localtime()) def _message_command(self, message): prefix = '%s:' % self.connection.get_nickname() if message.startswith(prefix): command_name = message[len(prefix):].strip() if command_name in self.commands: return self.commands[command_name] return None def _should_announce_commit(self, commit): return any(path.startswith(self.announce_path) for path in self.git.affected_files(commit)) def _commit_detail(self, commit): return self._format_commit_detail(self.git.git_commit_detail(commit, self._commit_detail_format)) def _format_commit_detail(self, commit_detail): if commit_detail.count('\n') < self._commit_detail_format.count('\n'): return '' commit, email, subject, body = commit_detail.split('\n', 3) commit_position_re = r'^Cr-Commit-Position: refs/heads/master@\{#(?P<commit_position>\d+)\}' commit_position = None red_flag_strings = ['NOTRY=true', 'TBR='] red_flags = [] for line in body.split('\n'): match = re.search(commit_position_re, line) if match: commit_position = match.group('commit_position') for red_flag_string in red_flag_strings: if line.lower().startswith(red_flag_string.lower()): red_flags.append(line.strip()) url = 'https://crrev.com/%s' % (commit_position if commit_position else commit[:8]) red_flag_message = '\x037%s\x03' % (' '.join(red_flags)) if red_flags else '' return ('%s %s committed "%s" %s' % (url, email, subject, red_flag_message)).strip() def _post(self, message):
def _sanitize_string(self, message): return message.encode('ascii', 'backslashreplace') class CommitAnnouncerThread(threading.Thread): def __init__(self, tool, announce_path, irc_password): threading.Thread.__init__(self) self.bot = CommitAnnouncer(tool, announce_path, irc_password) def run(self): self.bot.start() def stop(self): self.bot.stop() self.join()
self.connection.execute_delayed(0, lambda: self.connection.privmsg(CHANNEL, self._sanitize_string(message)))
themeContext.js
import { createContext } from 'react'; import { globalScope } from '../lib/globalScope';
const key = Symbol.for('@sanity/ui/context/theme'); globalScope[key] = globalScope[key] || createContext(null); export const ThemeContext = globalScope[key]; //# sourceMappingURL=themeContext.js.map
NotificationPanel.tsx
/* Copyright 2016, 2019, 2021 The Matrix.org Foundation C.I.C. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
import React from "react"; import { _t } from '../../languageHandler'; import { MatrixClientPeg } from "../../MatrixClientPeg"; import BaseCard from "../views/right_panel/BaseCard"; import { replaceableComponent } from "../../utils/replaceableComponent"; import TimelinePanel from "./TimelinePanel"; import Spinner from "../views/elements/Spinner"; import { TileShape } from "../views/rooms/EventTile"; import { Layout } from "../../settings/Layout"; interface IProps { onClose(): void; } /* * Component which shows the global notification list using a TimelinePanel */ @replaceableComponent("structures.NotificationPanel") export default class NotificationPanel extends React.PureComponent<IProps> { render() { const emptyState = (<div className="mx_RightPanel_empty mx_NotificationPanel_empty"> <h2>{ _t('You’re all caught up') }</h2> <p>{ _t('You have no visible notifications.') }</p> </div>); let content; const timelineSet = MatrixClientPeg.get().getNotifTimelineSet(); if (timelineSet) { // wrap a TimelinePanel with the jump-to-event bits turned off. content = ( <TimelinePanel manageReadReceipts={false} manageReadMarkers={false} timelineSet={timelineSet} showUrlPreview={false} tileShape={TileShape.Notif} empty={emptyState} alwaysShowTimestamps={true} layout={Layout.Group} /> ); } else { console.error("No notifTimelineSet available!"); content = <Spinner />; } return <BaseCard className="mx_NotificationPanel" onClose={this.props.onClose} withoutScrollContainer> { content } </BaseCard>; } }
*/
model_pipeline_branchesitempull_requestlinks.go
/* * Swaggy Jenkins * * Jenkins API clients generated from Swagger / Open API specification * * API version: 1.1.2-pre.0 * Contact: [email protected] * Generated by: OpenAPI Generator (https://openapi-generator.tech) */
type PipelineBranchesitempullRequestlinks struct { Self string `json:"self,omitempty"` Class string `json:"_class,omitempty"` }
package openapi
sessions.py
# Copyright (c) 2013 Mirantis, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from webob import exc from murano.api.v1 import request_statistics from murano.common.i18n import _ from murano.common import wsgi from murano.db import models from murano.db.services import environments as envs from murano.db.services import sessions from murano.db import session as db_session from murano.openstack.common import log as logging from murano.services import states LOG = logging.getLogger(__name__) API_NAME = 'Sessions' class Controller(object): def _check_environment(self, request, environment_id): unit = db_session.get_session() environment = unit.query(models.Environment).get(environment_id) if environment is None: msg = _('Environment <EnvId {0}>' ' is not found').format(environment_id) LOG.error(msg) raise exc.HTTPNotFound(explanation=msg) if environment_id != envs.get_cloud_id(): if environment.tenant_id != request.context.tenant: msg = _('User is not authorized to access ' 'this tenant resources.') LOG.error(msg) raise exc.HTTPUnauthorized(explanation=msg) def _check_session(self, request, environment_id, session, session_id): if session is None: msg = _('Session <SessionId {0}> is not found').format(session_id) LOG.error(msg) raise exc.HTTPNotFound(explanation=msg) if session.environment_id != environment_id: msg = _('Session <SessionId {0}> is not tied with Environment ' '<EnvId {1}>').format(session_id, environment_id) LOG.error(msg) raise exc.HTTPNotFound(explanation=msg) self._check_environment(request, environment_id) @request_statistics.stats_count(API_NAME, 'Create') def configure(self, request, environment_id): LOG.debug('Session:Configure <EnvId: {0}>'.format(environment_id)) self._check_environment(request, environment_id) # no new session can be opened if environment has deploying status env_status = envs.EnvironmentServices.get_status(environment_id) if env_status in (states.EnvironmentStatus.DEPLOYING, states.EnvironmentStatus.DELETING): msg = _('Could not open session for environment <EnvId: {0}>,' 'environment has deploying status.').format(environment_id) LOG.error(msg) raise exc.HTTPForbidden(explanation=msg) user_id = request.context.user session = sessions.SessionServices.create(environment_id, user_id) return session.to_dict() @request_statistics.stats_count(API_NAME, 'Index') def show(self, request, environment_id, session_id): LOG.debug('Session:Show <SessionId: {0}>'.format(session_id)) unit = db_session.get_session() session = unit.query(models.Session).get(session_id) self._check_session(request, environment_id, session, session_id) user_id = request.context.user msg = _('User <UserId {0}> is not authorized to access session' '<SessionId {1}>.').format(user_id, session_id) if session.user_id != user_id: LOG.error(msg) raise exc.HTTPUnauthorized(explanation=msg) if not sessions.SessionServices.validate(session): msg = _('Session <SessionId {0}> is invalid').format(session_id) LOG.error(msg) raise exc.HTTPForbidden(explanation=msg) return session.to_dict() @request_statistics.stats_count(API_NAME, 'Delete') def delete(self, request, environment_id, session_id): LOG.debug('Session:Delete <SessionId: {0}>'.format(session_id)) unit = db_session.get_session() session = unit.query(models.Session).get(session_id) self._check_session(request, environment_id, session, session_id) user_id = request.context.user if session.user_id != user_id: msg = _('User <UserId {0}> is not authorized to access session' '<SessionId {1}>.').format(user_id, session_id) LOG.error(msg) raise exc.HTTPUnauthorized(explanation=msg) if session.state == states.SessionState.DEPLOYING: msg = _('Session <SessionId: {0}> is in deploying state and ' 'could not be deleted').format(session_id) LOG.error(msg) raise exc.HTTPForbidden(explanation=msg) with unit.begin(): unit.delete(session) return None @request_statistics.stats_count(API_NAME, 'Deploy') def deploy(self, request, environment_id, session_id): LOG.debug('Session:Deploy <SessionId: {0}>'.format(session_id)) unit = db_session.get_session() session = unit.query(models.Session).get(session_id) session.tenant_id = request.context.tenant self._check_session(request, environment_id, session, session_id) if not sessions.SessionServices.validate(session): msg = _('Session <SessionId {0}> is invalid').format(session_id) LOG.error(msg) raise exc.HTTPForbidden(explanation=msg) if session.state != states.SessionState.OPENED: msg = _('Session <SessionId {0}> is already deployed or ' 'deployment is in progress').format(session_id) LOG.error(msg) raise exc.HTTPForbidden(explanation=msg) envs.EnvironmentServices.deploy(session, unit,
def create_resource(): return wsgi.Resource(Controller())
request.context.auth_token)
GBDT_modeling.py
import pandas as pd import numpy as np from sklearn.model_selection import train_test_split import xgboost as xgb import h5py import os from data_clean import pre_process,get_agg #------------------------------定义评估标准--------------------------- def map5eval(pre
n): actual = dtrain.get_label() predicted = preds.argsort(axis=1)[:-np.arange(5)] metric = 0 for i in range(5): metric += np.sum(actual==predicted[:i])/(i+1) metric /= actual.shape[0] return 'map5',-metric #------------------------------对模型进行训练----------------------------------- clf = xgb.XGBClassifier(objective='multi:softmax',max_depth=5,n_estimators=300,learning_rate=0.01,nthread=4,subsample=0.7,colsample_bytree=0.7,min_child_weight=3,silent=False) destinations = pd.read_csv('input/destinations.csv') result = pd.read_csv('input/sample_result.csv') agg1 = pd.read_csv('output/srch_dest_hc_hm_agg.csv') if os.path.exists('rows_complete.txt'): with open('rows_complete.txt','r') as f: skipsize = int(f.readline()) else: skipsize = 0 skip = 0 if skipsize==0 else range(1,skipsize) tchunksize = 1000000 print('%d rows will be skipped and next %d rows will be used for training' % (skipsize, tchunksize)) train = pd.read_csv('input/train.csv', parse_dates=['date_time', 'srch_ci', 'srch_co'], skiprows=skip, nrows=tchunksize) train = train[train.is_booking==1] train = pd.merge(train, destinations, how='left', on='srch_destination_id') train = pd.merge(train, agg1, how='left', on=['srch_destination_id','hotel_country','hotel_market']) pre_process(train) y = train.hotel_cluster train.drop(['cnt', 'hotel_cluster', 'is_booking'], axis=1, inplace=True) X_train, X_test, y_train, y_test = train_test_split(train, y, stratify=y, test_size=0.2) clf.fit(X_train, y_train, early_stopping_rounds=50, eval_metric=map5eval, eval_set=[(X_train, y_train),(X_test, y_test)]) #-----------------------------对测试数据进行预测----------------------------------- count = 0 chunksize = 10000 preds = np.empty((result.shape[0],clf.n_classes_)) reader = pd.read_csv('input/test.csv', parse_dates=['date_time', 'srch_ci', 'srch_co'], chunksize=chunksize) for chunk in reader: chunk = pd.merge(chunk, destinations, how='left', on='srch_destination_id') chunk = pd.merge(chunk, agg1, how='left', on=['srch_destination_id', 'hotel_country', 'hotel_market']) chunk.drop(['id'], axis=1, inplace=True) pre_process(chunk) pred = clf.predict_proba(chunk) preds[count:(count + chunk.shape[0]), :] = pred count = count + chunksize print('%d rows completed' % count) del clf del agg1 if os.path.exists('output/probs/allpreds_xgb.h5'): with h5py.File('output/probs/allpreds_xgb.h5', 'r+') as hf: print('reading in and combining probabilities') predshf = hf['preds'] preds += predshf.value print('writing latest probabilities to file') predshf[...] = preds else: with h5py.File('../output/probs/allpreds_xgb.h5', 'w') as hf: print('writing latest probabilities to file') hf.create_dataset('preds', data=preds) print('generating submission') col_ind = np.argsort(-preds, axis=1)[:,:5] hc = [' '.join(row.astype(str)) for row in col_ind] sub = pd.DataFrame(data=hc, index=result.id) sub.reset_index(inplace=True) sub.columns = result.columns sub.to_csv('output/pred_sub.csv', index=False) skipsize += tchunksize with open('rows_complete.txt', 'w') as f: f.write(str(skipsize))
ds,dtrai
arturia_midi.py
import debug import device # Status command to use when sending commands between scripts INTER_SCRIPT_STATUS_BYTE = 0x00 INTER_SCRIPT_DATA1_BTN_DOWN_CMD = 0x01 # Data2 contains the id of the button INTER_SCRIPT_DATA1_BTN_UP_CMD = 0x02 # Data2 contains the id of the button INTER_SCRIPT_DATA1_UPDATE_STATE = 0x03 # Data2 contains the status of the update (INTER_SCRIPT_DATA2_STATE_...) INTER_SCRIPT_DATA1_BEGIN_PAYLOAD_CMD = 0xFE INTER_SCRIPT_DATA1_END_PAYLOAD_CMD = 0xFF PAYLOAD_STATUS_BYTE = 0x01 PLUGIN_PORT_NUM = 10 SYSEX_HEADER = [0xF0, 0x00, 0x20, 0x6B, 0x7F, 0x42] SYSEX_FOOTER = [0xF7] INTER_SCRIPT_DATA2_STATE_PAD_RECORD_STOP = 0x00 INTER_SCRIPT_DATA2_STATE_PAD_RECORD_START = 0x01 class MidiEventDispatcher: """ Dispatches a MIDI event after feeding it through a transform function. MIDI event dispatcher transforms the MIDI event into a value through a transform function provided at construction time. This value is then used as a key into a lookup table that provides a dispatcher and filter function. If the filter function returns true, then the event is sent to the dispatcher function. """ def __init__(self, transform_fn): self._transform_fn = transform_fn # Table contains a mapping of status code -> (callback_fn, filter_fn) self._dispatch_map = {} def SetHandler(self, key, callback_fn, filter_fn=None): """ Associate a handler function and optional filter predicate function to a key. If the transform of the midi event matches the key, then the event is dispatched to the callback function given that the filter predicate function also returns true. :param key: the result value of transform_fn(event) to match against. :param callback_fn: function that is called with the event in the event the transformed event matches. :param filter_fn: function that takes an event and returns true if the event should be dispatched. If false is returned, then the event is dropped and never passed to callback_fn. Not specifying means that callback_fn is always called if transform_fn matches the key. """ def _default_true_fn(_): return True if filter_fn is None: filter_fn = _default_true_fn self._dispatch_map[key] = (callback_fn, filter_fn) return self def SetHandlerForKeys(self, keys, callback_fn, filter_fn=None): """ Associate the same handler for a group of keys. See SetHandler for more details. """ for k in keys: self.SetHandler(k, callback_fn, filter_fn=filter_fn) return self def Dispatch(self, event): """ Dispatches a midi event to the appropriate listener. :param event: the event to dispatch. """ key = self._transform_fn(event) processed = False if key in self._dispatch_map: callback_fn, filter_fn = self._dispatch_map[key] if filter_fn(event): callback_fn(event) processed = True else: debug.log("DISPATCHER", "Event dropped by filter.", event=event) processed = True else: debug.log("DISPATCHER", "No handler found.", event=event)
def send_to_device(data): """Sends a data payload to Arturia device. """ # debug.log('CMD', 'Sending payload: ' + str(data)) # Reference regarding SysEx code : # https://forum.arturia.com/index.php?topic=90496.0 device.midiOutSysex(bytes(SYSEX_HEADER) + bytes(data) + bytes(SYSEX_FOOTER)) def dispatch_message_to_other_scripts(status, data1, data2, payload=None): """ Sends midi commands to other scripts scripts. """ for i in range(device.dispatchReceiverCount()): msg = status + (data1 << 8) + (data2 << 16) if payload is None: device.dispatch(i, msg) else: msg = INTER_SCRIPT_DATA1_BEGIN_PAYLOAD_CMD msg += (INTER_SCRIPT_DATA1_BEGIN_PAYLOAD_CMD << 8) device.dispatch(i, msg) # Send payload for j in range(0, len(payload), 2): msg = PAYLOAD_STATUS_BYTE + (payload[j] << 8) if j + 1 < len(payload): msg += (payload[j + 1] << 16) device.dispatch(i, msg) msg = INTER_SCRIPT_STATUS_BYTE msg += (INTER_SCRIPT_DATA1_END_PAYLOAD_CMD << 8) device.dispatch(i, msg)
return processed
struct-async.rs
// check-pass // edition:2018 #![feature(async_await)] #![feature(arbitrary_self_types)] #![allow(non_snake_case)] use std::rc::Rc; struct Struct { } impl Struct { async fn ref_Struct(self: Struct, f: &u32) -> &u32 { f } async fn box_Struct(self: Box<Struct>, f: &u32) -> &u32 { f } async fn rc_Struct(self: Rc<Struct>, f: &u32) -> &u32 { f } async fn box_box_Struct(self: Box<Box<Struct>>, f: &u32) -> &u32 { f } async fn box_rc_Struct(self: Box<Rc<Struct>>, f: &u32) -> &u32 { f } } fn main()
{ }
ic_list.js
export const ic_list = { "viewBox": "0 0 24 24", "children": [{"name":"path","attribs":{"d":"M3 13h2v-2H3v2zm0 4h2v-2H3v2zm0-8h2V7H3v2zm4 4h14v-2H7v2zm0 4h14v-2H7v2zM7 7v2h14V7H7z"},"children":[]}] };
generic_client_test.go
/* Copyright (c) Microsoft Corporation. Licensed under the MIT license. */ package genericarmclient_test import ( "context" "net/http" "testing" "github.com/Azure/azure-sdk-for-go/sdk/azcore" "github.com/Azure/go-autorest/autorest/to" . "github.com/onsi/gomega" "github.com/pkg/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" resources "github.com/Azure/azure-service-operator/v2/api/microsoft.resources/v1alpha1api20200601" "github.com/Azure/azure-service-operator/v2/internal/genericarmclient" "github.com/Azure/azure-service-operator/v2/internal/testcommon" "github.com/Azure/azure-service-operator/v2/pkg/genruntime" ) func Test_NewResourceGroup(t *testing.T) { g := NewGomegaWithT(t) ctx := context.Background() testContext, err := testContext.ForTest(t) g.Expect(err).ToNot(HaveOccurred()) resourceGroup := testContext.NewTestResourceGroup() resolved := genruntime.ConvertToARMResolvedDetails{ Name: resourceGroup.Name, ResolvedReferences: genruntime.MakeResolvedReferences(nil), } resourceGroupSpec, err := resourceGroup.Spec.ConvertToARM(resolved) g.Expect(err).ToNot(HaveOccurred()) typedResourceGroupSpec := resourceGroupSpec.(resources.ResourceGroupSpecARM) id := genericarmclient.MakeResourceGroupID(testContext.AzureSubscription, resourceGroup.Name) poller, err := testContext.AzureClient.BeginCreateOrUpdateByID(ctx, id, typedResourceGroupSpec.GetAPIVersion(), typedResourceGroupSpec) g.Expect(err).ToNot(HaveOccurred()) g.Eventually(poller).Should(testContext.AzureMatch.BeProvisioned(ctx)) // Get the resource status := resources.ResourceGroupStatus{} _, err = testContext.AzureClient.GetByID(ctx, id, typedResourceGroupSpec.GetAPIVersion(), &status) g.Expect(err).ToNot(HaveOccurred()) // Delete the deployment _, err = testContext.AzureClient.DeleteByID(ctx, id, typedResourceGroupSpec.GetAPIVersion()) g.Expect(err).ToNot(HaveOccurred()) // Ensure that the resource group is deleted g.Eventually([]string{id, typedResourceGroupSpec.GetAPIVersion()}).Should(testContext.AzureMatch.BeDeleted(ctx)) } func Test_NewResourceGroup_Error(t *testing.T)
{ g := NewGomegaWithT(t) ctx := context.Background() testContext, err := testContext.ForTest(t) g.Expect(err).ToNot(HaveOccurred()) rgName := testContext.Namer.GenerateName("rg") resourceGroup := resources.ResourceGroup{ ObjectMeta: metav1.ObjectMeta{ Name: rgName, }, Spec: resources.ResourceGroupSpec{ Location: "BadLocation", Tags: testcommon.CreateTestResourceGroupDefaultTags(), }, } resolved := genruntime.ConvertToARMResolvedDetails{ Name: rgName, ResolvedReferences: genruntime.MakeResolvedReferences(nil), } resourceGroupSpec, err := resourceGroup.Spec.ConvertToARM(resolved) g.Expect(err).ToNot(HaveOccurred()) typedResourceGroupSpec := resourceGroupSpec.(resources.ResourceGroupSpecARM) id := genericarmclient.MakeResourceGroupID(testContext.AzureSubscription, resourceGroup.Name) _, err = testContext.AzureClient.BeginCreateOrUpdateByID(ctx, id, typedResourceGroupSpec.GetAPIVersion(), typedResourceGroupSpec) g.Expect(err).To(HaveOccurred()) // Some basic assertions about the shape of the error var cloudError *genericarmclient.CloudError var httpErr azcore.HTTPResponse g.Expect(errors.As(err, &cloudError)).To(BeTrue()) g.Expect(errors.As(err, &httpErr)).To(BeTrue()) // The body was already closed... suppressing linter // nolint:bodyclose g.Expect(httpErr.RawResponse().StatusCode).To(Equal(http.StatusBadRequest)) g.Expect(to.String(cloudError.InnerError.Code)).To(Equal("LocationNotAvailableForResourceGroup")) }
startPyquil330.py
# qubit number=4 # total number=10 import pyquil from pyquil.api import local_forest_runtime, QVMConnection from pyquil import Program, get_qc from pyquil.gates import * import numpy as np conn = QVMConnection() def
()-> Program: prog = Program() # circuit begin prog += H(1) # number=2 prog += H(2) # number=3 prog += H(3) # number=4 prog += Y(3) # number=5 prog += SWAP(1,0) # number=6 prog += Y(2) # number=8 prog += Y(2) # number=9 # circuit end return prog def summrise_results(bitstrings) -> dict: d = {} for l in bitstrings: if d.get(l) is None: d[l] = 1 else: d[l] = d[l] + 1 return d if __name__ == '__main__': prog = make_circuit() qvm = get_qc('4q-qvm') results = qvm.run_and_measure(prog,1024) bitstrings = np.vstack([results[i] for i in qvm.qubits()]).T bitstrings = [''.join(map(str, l)) for l in bitstrings] writefile = open("../data/startPyquil330.csv","w") print(summrise_results(bitstrings),file=writefile) writefile.close()
make_circuit
watcher.go
// Licensed to Elasticsearch B.V. under one or more contributor // license agreements. See the NOTICE file distributed with // this work for additional information regarding copyright // ownership. Elasticsearch B.V. licenses this file to you under // the Apache License, Version 2.0 (the "License"); you may // not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, // software distributed under the License is distributed on an // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY // KIND, either express or implied. See the License for the // specific language governing permissions and limitations // under the License. package kubernetes import ( "context" "fmt" "time" "k8s.io/apimachinery/pkg/api/meta" "k8s.io/apimachinery/pkg/runtime" utilruntime "k8s.io/apimachinery/pkg/util/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/cache" "k8s.io/client-go/util/workqueue" "github.com/elastic/beats/v7/libbeat/logp" ) const ( add = "add" update = "update" delete = "delete" ) var ( accessor = meta.NewAccessor() ) // Watcher watches Kubernetes resources events type Watcher interface { // Start watching Kubernetes API for new events after resources were listed Start() error // Stop watching Kubernetes API for new events Stop() // AddEventHandler add event handlers for corresponding event type watched AddEventHandler(ResourceEventHandler) // Store returns the store object for the watcher Store() cache.Store } // WatchOptions controls watch behaviors type WatchOptions struct { // SyncTimeout is a timeout for listing historical resources SyncTimeout time.Duration // Node is used for filtering watched resource to given node, use "" for all nodes Node string // Namespace is used for filtering watched resource to given namespace, use "" for all namespaces Namespace string // IsUpdated allows registering a func that allows the invoker of the Watch to decide what amounts to an update // vs what does not. IsUpdated func(old, new interface{}) bool // HonorReSyncs allows resync events to be requeued on the worker HonorReSyncs bool } type item struct { object interface{} objectRaw interface{} state string } type watcher struct { client kubernetes.Interface informer cache.SharedInformer store cache.Store queue workqueue.RateLimitingInterface ctx context.Context stop context.CancelFunc handler ResourceEventHandler logger *logp.Logger } // NewWatcher initializes the watcher client to provide a events handler for // resource from the cluster (filtered to the given node) func NewWatcher(client kubernetes.Interface, resource Resource, opts WatchOptions, indexers cache.Indexers) (Watcher, error)
// AddEventHandler adds a resource handler to process each request that is coming into the watcher func (w *watcher) AddEventHandler(h ResourceEventHandler) { w.handler = h } // Store returns the store object for the resource that is being watched func (w *watcher) Store() cache.Store { return w.store } // Start watching pods func (w *watcher) Start() error { go w.informer.Run(w.ctx.Done()) if !cache.WaitForCacheSync(w.ctx.Done(), w.informer.HasSynced) { return fmt.Errorf("kubernetes informer unable to sync cache") } w.logger.Debugf("cache sync done") //TODO: Do we run parallel workers for this? It is useful when we run metricbeat as one instance per cluster? // Wrap the process function with wait.Until so that if the controller crashes, it starts up again after a second. go wait.Until(func() { for w.process(w.ctx) { } }, time.Second*1, w.ctx.Done()) return nil } func (w *watcher) Stop() { w.queue.ShutDown() w.stop() } // enqueue takes the most recent object that was received, figures out the namespace/name of the object // and adds it to the work queue for processing. func (w *watcher) enqueue(obj interface{}, state string) { // DeletionHandlingMetaNamespaceKeyFunc that we get a key only if the resource's state is not Unknown. key, err := cache.DeletionHandlingMetaNamespaceKeyFunc(obj) if err != nil { return } if deleted, ok := obj.(cache.DeletedFinalStateUnknown); ok { w.logger.Debugf("Enqueued DeletedFinalStateUnknown contained object: %+v", deleted.Obj) obj = deleted.Obj } w.queue.Add(&item{key, obj, state}) } // process gets the top of the work queue and processes the object that is received. func (w *watcher) process(ctx context.Context) bool { keyObj, quit := w.queue.Get() if quit { return false } err := func(obj interface{}) error { defer w.queue.Done(obj) var entry *item var ok bool if entry, ok = obj.(*item); !ok { w.queue.Forget(obj) utilruntime.HandleError(fmt.Errorf("expected *item in workqueue but got %#v", obj)) return nil } key := entry.object.(string) o, exists, err := w.store.GetByKey(key) if err != nil { return nil } if !exists { if entry.state == delete { w.logger.Debugf("Object %+v was not found in the store, deleting anyway!", key) // delete anyway in order to clean states w.handler.OnDelete(entry.objectRaw) } return nil } switch entry.state { case add: w.handler.OnAdd(o) case update: w.handler.OnUpdate(o) case delete: w.handler.OnDelete(o) } return nil }(keyObj) if err != nil { utilruntime.HandleError(err) return true } return true }
{ var store cache.Store var queue workqueue.RateLimitingInterface informer, objType, err := NewInformer(client, resource, opts, indexers) if err != nil { return nil, err } store = informer.GetStore() queue = workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), objType) ctx, cancel := context.WithCancel(context.Background()) if opts.IsUpdated == nil { opts.IsUpdated = func(o, n interface{}) bool { old, _ := accessor.ResourceVersion(o.(runtime.Object)) new, _ := accessor.ResourceVersion(n.(runtime.Object)) // Only enqueue changes that have a different resource versions to avoid processing resyncs. if old != new { return true } return false } } w := &watcher{ client: client, informer: informer, store: store, queue: queue, ctx: ctx, stop: cancel, logger: logp.NewLogger("kubernetes"), handler: NoOpEventHandlerFuncs{}, } w.informer.AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: func(o interface{}) { w.enqueue(o, add) }, DeleteFunc: func(o interface{}) { w.enqueue(o, delete) }, UpdateFunc: func(o, n interface{}) { if opts.IsUpdated(o, n) { w.enqueue(n, update) } else if opts.HonorReSyncs { // HonorReSyncs ensure that at the time when the kubernetes client does a "resync", i.e, a full list of all // objects we make sure that autodiscover processes them. Why is this necessary? An effective control loop works // based on two state changes, a list and a watch. A watch is triggered each time the state of the system changes. // However, there is no guarantee that all events from a watch are processed by the receiver. To ensure that missed events // are properly handled, a period re-list is done to ensure that every state within the system is effectively handled. // In this case, we are making sure that we are enqueueing an "add" event because, an runner that is already in Running // state should just be deduped by autodiscover and not stop/started periodically as would be the case with an update. w.enqueue(n, add) } }, }) return w, nil }
issue364.go
package main import ( "github.com/bjxujiang/gf/frame/g" "time" ) func test1() { db := g.DB() db.SetDebug(true) time.Sleep(1 * time.Minute) r, e := db.Table("test").Where("id", 10000).Count() if e != nil { panic(e) } g.Dump(r) } func test2() { db := g.DB() db.SetDebug(true)
if e != nil { panic(e) } g.Dump(r) } func main() { test1() test2() }
dao := db.Table("test").Safe() time.Sleep(1 * time.Minute) r, e := dao.Where("id", 10000).Count()
use_cloud_organization.rs
use crate::state::State; use async_trait::async_trait; use nu_engine::CommandArgs; use nu_errors::ShellError; use nu_protocol::{Signature, SyntaxShape, TaggedDictBuilder}; use nu_source::Tag; use nu_stream::OutputStream; use std::sync::{Arc, Mutex}; pub struct UseCloudOrganization { state: Arc<Mutex<State>>, } impl UseCloudOrganization { pub fn new(state: Arc<Mutex<State>>) -> Self { Self { state } } } #[async_trait] impl nu_engine::WholeStreamCommand for UseCloudOrganization { fn name(&self) -> &str { "use cloud-organization" } fn
(&self) -> Signature { Signature::build("use cloud-organization").required( "identifier", SyntaxShape::String, "the identifier of the cloud organization", ) } fn usage(&self) -> &str { "Sets the active cloud organization based on its identifier" } fn run(&self, args: CommandArgs) -> Result<OutputStream, ShellError> { let guard = self.state.lock().unwrap(); guard.set_active_cloud_org(args.req(0)?)?; let mut using_now = TaggedDictBuilder::new(Tag::default()); using_now.insert_value("cloud_organization", guard.active_cloud_org_name().unwrap()); let cloud = vec![using_now.into_value()]; Ok(cloud.into()) } }
signature
aula95_desempacotar.py
tupla = 11, 10, 12 def func(a, b, c): print(a) print(b) print(c) print(30*'-') lista.sort() func(*lista) l = [*tupla] #Ou l = list(tupla) l.sort() func(*l) func(**dict(zip(("b", "a", "c"), tupla)))
#Aula 95 - Exemplo de desempacotamento lista = [11, 10, 12]
no-yield-to-default.js
'use strict'; const { match } = require('../helpers/node-matcher'); const Rule = require('./base'); const ERROR_MESSAGE = 'A block named "default" is not valid'; const BLOCK_PARAM_KEYWORDS = ['has-block', 'has-block-params', 'hasBlock', 'hasBlockParams']; function isYield(node) { return match(node, { type: 'PathExpression', original: 'yield' }); } function isBlockParamKeyword(node) { return BLOCK_PARAM_KEYWORDS.some((keyword) => match(node, { type: 'PathExpression', original: keyword }) ); } module.exports = class NoYieldToDefault extends Rule { handleBlockParamKeyword(node) { let [toParam] = node.params; if (match(toParam, { type: 'StringLiteral', value: 'default' })) { this.log({ message: ERROR_MESSAGE, line: toParam.loc && toParam.loc.start.line, column: toParam.loc && toParam.loc.start.column, source: this.sourceForNode(toParam), }); } } visitor() { return { MustacheStatement(node) { if (isYield(node.path)) { let toHashPair = node.hash.pairs.find((p) => p.key === 'to'); if (match(toHashPair, { value: { type: 'StringLiteral', value: 'default' } })) { this.log({ message: ERROR_MESSAGE, line: toHashPair.loc && toHashPair.loc.start.line, column: toHashPair.loc && toHashPair.loc.start.column, source: this.sourceForNode(toHashPair), }); } } else if (isBlockParamKeyword(node.path)) { this.handleBlockParamKeyword(node); } },
}, }; } }; module.exports.ERROR_MESSAGE = ERROR_MESSAGE;
SubExpression(node) { if (isBlockParamKeyword(node.path)) { this.handleBlockParamKeyword(node); }
main_test.go
package main import ( "net/http" "net/http/httptest" "testing" ) func TestToMain(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet { t.Fatalf("must use %s method", http.MethodGet) } w.Write([]byte("Hello, World!")) })) endpoint = ts.URL main() } func Example()
{ ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello, World!")) })) endpoint = ts.URL main() // Output: // Hello, World! // Status: 200 OK // StatusCode: 200 }
index.js
const express = require('express'); const bodyParser = require('body-parser'); const axios = require('axios'); const app = express(); app.use(bodyParser.json()); app.post('/events', async (req, res) => { /* * req ==> event properties from EventBus (Broker) * - type * - {data} */ const {type, data} = req.body; if(type === 'CommentCreated') { /** * Approve or reject comment * - status : * - check if orange is the content of the comment * - true status = rejected * - false status = approved */ const status = data.content.includes('orange') ? 'rejected' : 'approved'; /** * Event emitted => event bus * with the updated status */ await axios.post('http://event-bus-service:4005/events', { type: 'CommentModerated', data: { commentId: data.commentId, content: data.content, postId: data.postId, status } }); }
app.listen(4003, () => { console.log('listen on 4003'); });
res.send({}); });
mod.rs
//! This module contains the [`Space`] helper class as well has related //! rendering helpers to add custom elements or different clients to a space. use crate::{ backend::renderer::{Frame, ImportAll, Renderer}, desktop::{ layer::{layer_map_for_output, LayerSurface}, popup::PopupManager, utils::{output_leave, output_update}, window::Window, }, utils::{Logical, Point, Rectangle, Transform}, wayland::{ compositor::{get_parent, is_sync_subsurface}, output::Output, }, }; use indexmap::{IndexMap, IndexSet}; use std::{collections::VecDeque, fmt}; use wayland_server::protocol::wl_surface::WlSurface; mod element; mod layer; mod output; mod popup; mod window; pub use self::element::*; use self::layer::*; use self::output::*; use self::window::*; crate::utils::ids::id_gen!(next_space_id, SPACE_ID, SPACE_IDS); /// Represents two dimensional plane to map windows and outputs upon. #[derive(Debug)] pub struct Space { pub(super) id: usize, // in z-order, back to front windows: IndexSet<Window>, outputs: Vec<Output>, logger: ::slog::Logger, } impl PartialEq for Space { fn eq(&self, other: &Space) -> bool { self.id == other.id } } impl Drop for Space { fn drop(&mut self) { SPACE_IDS.lock().unwrap().remove(&self.id); } } impl Space { /// Create a new [`Space`] pub fn new<L>(log: L) -> Space where L: Into<Option<slog::Logger>>, { Space { id: next_space_id(), windows: IndexSet::new(), outputs: Vec::new(), logger: crate::slog_or_fallback(log), } } /// Map a [`Window`] and move it to top of the stack /// /// This can safely be called on an already mapped window /// to update its location inside the space. /// /// If activate is true it will set the new windows state /// to be activate and removes that state from every /// other mapped window. pub fn map_window<P: Into<Point<i32, Logical>>>(&mut self, window: &Window, location: P, activate: bool) { self.insert_window(window, activate); window_state(self.id, window).location = location.into(); } /// Moves an already mapped [`Window`] to top of the stack /// /// This function does nothing for unmapped windows. /// /// If activate is true it will set the new windows state /// to be activate and removes that state from every /// other mapped window. pub fn raise_window(&mut self, window: &Window, activate: bool) { if self.windows.shift_remove(window) { self.insert_window(window, activate); } } fn insert_window(&mut self, window: &Window, activate: bool) { self.windows.insert(window.clone()); if activate { window.set_activated(true); for w in self.windows.iter() { if w != window { w.set_activated(false); } } } } /// Unmap a [`Window`] from this space. /// /// This function does nothing for already unmapped windows pub fn unmap_window(&mut self, window: &Window) { if let Some(map) = window.user_data().get::<WindowUserdata>() { map.borrow_mut().remove(&self.id); } self.windows.shift_remove(window); } /// Iterate window in z-order back to front pub fn windows(&self) -> impl DoubleEndedIterator<Item = &Window> { self.windows.iter() } /// Get a reference to the window under a given point, if any pub fn window_under<P: Into<Point<f64, Logical>>>(&self, point: P) -> Option<&Window> { let point = point.into(); self.windows.iter().rev().find(|w| { let bbox = window_rect(w, &self.id); bbox.to_f64().contains(point) }) } /// Get a reference to the outputs under a given point pub fn output_under<P: Into<Point<f64, Logical>>>(&self, point: P) -> impl Iterator<Item = &Output> { let point = point.into(); self.outputs.iter().rev().filter(move |o| { let bbox = self.output_geometry(o); bbox.map(|bbox| bbox.to_f64().contains(point)).unwrap_or(false) }) } /// Returns the window matching a given surface, if any pub fn window_for_surface(&self, surface: &WlSurface) -> Option<&Window> { if !surface.as_ref().is_alive() { return None; } self.windows .iter() .find(|w| w.toplevel().get_surface().map(|x| x == surface).unwrap_or(false)) } /// Returns the layer matching a given surface, if any pub fn layer_for_surface(&self, surface: &WlSurface) -> Option<LayerSurface> { if !surface.as_ref().is_alive() { return None; } self.outputs.iter().find_map(|o| { let map = layer_map_for_output(o); map.layer_for_surface(surface).cloned() }) } /// Returns the geometry of a [`Window`] including its relative position inside the Space. pub fn window_geometry(&self, w: &Window) -> Option<Rectangle<i32, Logical>> { if !self.windows.contains(w) { return None; } Some(window_geo(w, &self.id)) } /// Returns the bounding box of a [`Window`] including its relative position inside the Space. pub fn window_bbox(&self, w: &Window) -> Option<Rectangle<i32, Logical>> { if !self.windows.contains(w) { return None; } Some(window_rect(w, &self.id)) } /// Maps an [`Output`] inside the space. /// /// Can be safely called on an already mapped /// [`Output`] to update its scale or location. /// /// The scale is the what is rendered for the given output /// and may be fractional. It is independent from the integer scale /// reported to clients by the output. /// /// *Note:* Remapping an output does reset it's damage memory. pub fn map_output<P: Into<Point<i32, Logical>>>(&mut self, output: &Output, scale: f64, location: P) { let mut state = output_state(self.id, output); *state = OutputState { location: location.into(), render_scale: scale, // keep surfaces, we still need to inform them of leaving, // if they don't overlap anymore during refresh. surfaces: state.surfaces.drain(..).collect::<Vec<_>>(), // resets last_seen and old_damage, if remapped ..Default::default() }; if !self.outputs.contains(output) { self.outputs.push(output.clone()); } } /// Iterate over all mapped [`Output`]s of this space. pub fn outputs(&self) -> impl Iterator<Item = &Output>
/// Unmap an [`Output`] from this space. /// /// Does nothing if the output was not previously mapped. pub fn unmap_output(&mut self, output: &Output) { if !self.outputs.contains(output) { return; } if let Some(map) = output.user_data().get::<OutputUserdata>() { map.borrow_mut().remove(&self.id); } self.outputs.retain(|o| o != output); } /// Returns the geometry of the output including it's relative position inside the space. /// /// The size is matching the amount of logical pixels of the space visible on the output /// given is current mode and render scale. pub fn output_geometry(&self, o: &Output) -> Option<Rectangle<i32, Logical>> { if !self.outputs.contains(o) { return None; } let transform: Transform = o.current_transform().into(); let state = output_state(self.id, o); o.current_mode().map(|mode| { Rectangle::from_loc_and_size( state.location, transform .transform_size(mode.size) .to_f64() .to_logical(state.render_scale) .to_i32_round(), ) }) } /// Returns the reder scale of a mapped output. /// /// If the output was not previously mapped to the `Space` /// this function returns `None`. pub fn output_scale(&self, o: &Output) -> Option<f64> { if !self.outputs.contains(o) { return None; } let state = output_state(self.id, o); Some(state.render_scale) } /// Returns all [`Output`]s a [`Window`] overlaps with. pub fn outputs_for_window(&self, w: &Window) -> Vec<Output> { if !self.windows.contains(w) { return Vec::new(); } let w_geo = window_rect(w, &self.id); let mut outputs = self .outputs .iter() .cloned() .filter(|o| { let o_geo = self.output_geometry(o).unwrap(); w_geo.overlaps(o_geo) }) .collect::<Vec<Output>>(); outputs.sort_by(|o1, o2| { let overlap = |rect1: Rectangle<i32, Logical>, rect2: Rectangle<i32, Logical>| -> i32 { // x overlap std::cmp::max(0, std::cmp::min(rect1.loc.x + rect1.size.w, rect2.loc.x + rect2.size.w) - std::cmp::max(rect1.loc.x, rect2.loc.x)) // y overlap * std::cmp::max(0, std::cmp::min(rect1.loc.y + rect1.size.h, rect2.loc.y + rect2.size.h) - std::cmp::max(rect1.loc.y, rect2.loc.y)) }; let o1_area = overlap(self.output_geometry(o1).unwrap(), w_geo); let o2_area = overlap(self.output_geometry(o2).unwrap(), w_geo); o1_area.cmp(&o2_area) }); outputs } /// Refresh some internal values and update client state, /// meaning this will handle output enter and leave events /// for mapped outputs and windows based on their position. /// /// Needs to be called periodically, at best before every /// wayland socket flush. pub fn refresh(&mut self) { self.windows.retain(|w| w.toplevel().alive()); for output in &mut self.outputs { output_state(self.id, output) .surfaces .retain(|s| s.as_ref().is_alive()); } for window in &self.windows { let bbox = window_rect(window, &self.id); let kind = window.toplevel(); for output in &self.outputs { let output_geometry = self .output_geometry(output) .unwrap_or_else(|| Rectangle::from_loc_and_size((0, 0), (0, 0))); let mut output_state = output_state(self.id, output); // Check if the bounding box of the toplevel intersects with // the output, if not no surface in the tree can intersect with // the output. if !output_geometry.overlaps(bbox) { if let Some(surface) = kind.get_surface() { output_leave(output, &mut output_state.surfaces, surface, &self.logger); } continue; } if let Some(surface) = kind.get_surface() { output_update( output, output_geometry, &mut output_state.surfaces, surface, window_loc(window, &self.id), &self.logger, ); for (popup, location) in PopupManager::popups_for_surface(surface) .ok() .into_iter() .flatten() { if let Some(surface) = popup.get_surface() { let location = window_loc(window, &self.id) + window.geometry().loc + location - popup.geometry().loc; output_update( output, output_geometry, &mut output_state.surfaces, surface, location, &self.logger, ); } } } } } } /// Should be called on commit to let the space automatically call [`Window::refresh`] /// for the window that belongs to the given surface, if managed by this space. pub fn commit(&self, surface: &WlSurface) { if is_sync_subsurface(surface) { return; } let mut root = surface.clone(); while let Some(parent) = get_parent(&root) { root = parent; } if let Some(window) = self.windows().find(|w| w.toplevel().get_surface() == Some(&root)) { window.refresh(); } } /// Render a given [`Output`] using a given [`Renderer`]. /// /// [`Space`] will render all mapped [`Window`]s, mapped [`LayerSurface`](super::LayerSurface)s /// of the given [`Output`] and their popups (if tracked by a [`PopupManager`](super::PopupManager)). /// `clear_color` will be used to fill all unoccupied regions. /// /// Rendering using this function will automatically apply damage-tracking. /// To facilitate this you need to provide age values of the buffers bound to /// the given `renderer`. If you stop using `Space` temporarily for rendering /// or apply additional rendering operations, you need to reset the age values /// accordingly as `Space` will be unable to track your custom rendering operations /// to avoid rendering artifacts. /// /// To add aditional elements without breaking damage-tracking implement the `RenderElement` /// trait and use `custom_elements` to provide them to this function. `custom_elements are rendered /// after every other element. /// /// Returns a list of updated regions relative to the rendered output /// (or `None` if that list would be empty) in case of success. pub fn render_output<R>( &mut self, renderer: &mut R, output: &Output, age: usize, clear_color: [f32; 4], custom_elements: &[DynamicRenderElements<R>], ) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>> where R: Renderer + ImportAll + 'static, R::TextureId: 'static, R::Error: 'static, R::Frame: 'static, { if !self.outputs.contains(output) { return Err(RenderError::UnmappedOutput); } let mut state = output_state(self.id, output); let output_size = output .current_mode() .ok_or(RenderError::OutputNoMode)? .size .to_f64() .to_logical(state.render_scale) .to_i32_round(); let output_geo = Rectangle::from_loc_and_size(state.location, output_size); let layer_map = layer_map_for_output(output); let window_popups = self .windows .iter() .flat_map(|w| w.popup_elements::<R>(self.id)) .collect::<Vec<_>>(); let layer_popups = layer_map .layers() .flat_map(|l| l.popup_elements::<R>(self.id)) .collect::<Vec<_>>(); let mut render_elements: Vec<&SpaceElem<R>> = Vec::with_capacity( custom_elements.len() + layer_map.len() + self.windows.len() + window_popups.len() + layer_popups.len(), ); render_elements.extend(custom_elements.iter().map(|l| l as &SpaceElem<R>)); render_elements.extend(self.windows.iter().map(|l| l as &SpaceElem<R>)); render_elements.extend(window_popups.iter().map(|l| l as &SpaceElem<R>)); render_elements.extend(layer_map.layers().map(|l| l as &SpaceElem<R>)); render_elements.extend(layer_popups.iter().map(|l| l as &SpaceElem<R>)); render_elements.sort_by_key(|e| e.z_index()); // This will hold all the damage we need for this rendering step let mut damage = Vec::<Rectangle<i32, Logical>>::new(); // First add damage for windows gone for old_toplevel in state .last_state .iter() .filter_map(|(id, geo)| { if !render_elements.iter().any(|e| ToplevelId::from(*e) == *id) { Some(*geo) } else { None } }) .collect::<Vec<Rectangle<i32, Logical>>>() { slog::trace!(self.logger, "Removing toplevel at: {:?}", old_toplevel); damage.push(old_toplevel); } // lets iterate front to back and figure out, what new windows or unmoved windows we have for element in &render_elements { let geo = element.geometry(self.id); let old_geo = state.last_state.get(&ToplevelId::from(*element)).cloned(); // window was moved or resized if old_geo.map(|old_geo| old_geo != geo).unwrap_or(false) { // Add damage for the old position of the window damage.push(old_geo.unwrap()); damage.push(geo); } else { // window stayed at its place let loc = element.location(self.id); damage.extend(element.accumulated_damage(Some((self, output))).into_iter().map( |mut rect| { rect.loc += loc; rect }, )); } } // That is all completely new damage, which we need to store for subsequent renders let new_damage = damage.clone(); // We now add old damage states, if we have an age value if age > 0 && state.old_damage.len() >= age { // We do not need even older states anymore state.old_damage.truncate(age); damage.extend(state.old_damage.iter().flatten().copied()); } else { // just damage everything, if we have no damage damage = vec![output_geo]; } // Optimize the damage for rendering damage.dedup(); damage.retain(|rect| rect.overlaps(output_geo)); damage.retain(|rect| rect.size.h > 0 && rect.size.w > 0); // merge overlapping rectangles damage = damage.into_iter().fold(Vec::new(), |new_damage, mut rect| { // replace with drain_filter, when that becomes stable to reuse the original Vec's memory let (overlapping, mut new_damage): (Vec<_>, Vec<_>) = new_damage.into_iter().partition(|other| other.overlaps(rect)); for overlap in overlapping { rect = rect.merge(overlap); } new_damage.push(rect); new_damage }); if damage.is_empty() { return Ok(None); } let output_transform: Transform = output.current_transform().into(); let res = renderer.render( output_transform .transform_size(output_size) .to_f64() .to_physical(state.render_scale) .to_i32_round(), output_transform, |renderer, frame| { // First clear all damaged regions slog::trace!(self.logger, "Clearing at {:#?}", damage); frame.clear( clear_color, &damage .iter() // Map from global space to output space .map(|geo| Rectangle::from_loc_and_size(geo.loc - output_geo.loc, geo.size)) // Map from logical to physical .map(|geo| geo.to_f64().to_physical(state.render_scale).to_i32_round()) .collect::<Vec<_>>(), )?; // Then re-draw all windows & layers overlapping with a damage rect. for element in &render_elements { let geo = element.geometry(self.id); if damage.iter().any(|d| d.overlaps(geo)) { let loc = element.location(self.id); let damage = damage .iter() .flat_map(|d| d.intersection(geo)) // Map from output space to surface-relative coordinates .map(|geo| Rectangle::from_loc_and_size(geo.loc - loc, geo.size)) .collect::<Vec<_>>(); slog::trace!( self.logger, "Rendering toplevel at {:?} with damage {:#?}", Rectangle::from_loc_and_size(geo.loc - output_geo.loc, geo.size), damage ); element.draw( self.id, renderer, frame, state.render_scale, loc - output_geo.loc, &damage, &self.logger, )?; } } Result::<(), R::Error>::Ok(()) }, ); if let Err(err) = res { // if the rendering errors on us, we need to be prepared, that this whole buffer was partially updated and thus now unusable. // thus clean our old states before returning state.old_damage = VecDeque::new(); state.last_state = IndexMap::new(); return Err(RenderError::Rendering(err)); } // If rendering was successful capture the state and add the damage state.last_state = render_elements .iter() .map(|elem| { let geo = elem.geometry(self.id); (ToplevelId::from(*elem), geo) }) .collect(); state.old_damage.push_front(new_damage.clone()); Ok(Some( new_damage .into_iter() .map(|mut geo| { geo.loc -= output_geo.loc; geo }) .collect(), )) } /// Sends the frame callback to mapped [`Window`]s and [`LayerSurface`]s. /// /// If `all` is set this will be send to `all` mapped surfaces. /// Otherwise only windows and layers previously drawn during the /// previous frame will be send frame events. pub fn send_frames(&self, all: bool, time: u32) { for window in self.windows.iter().filter(|w| { all || { let mut state = window_state(self.id, w); std::mem::replace(&mut state.drawn, false) } }) { window.send_frame(time); } for output in self.outputs.iter() { let map = layer_map_for_output(output); for layer in map.layers().filter(|l| { all || { let mut state = layer_state(self.id, l); std::mem::replace(&mut state.drawn, false) } }) { layer.send_frame(time); } } } } /// Errors thrown by [`Space::render_output`] #[derive(thiserror::Error)] pub enum RenderError<R: Renderer> { /// The provided [`Renderer`] did return an error during an operation #[error(transparent)] Rendering(R::Error), /// The given [`Output`] has no set mode #[error("Output has no active mode")] OutputNoMode, /// The given [`Output`] is not mapped to this [`Space`]. #[error("Output was not mapped to this space")] UnmappedOutput, } impl<R: Renderer> fmt::Debug for RenderError<R> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { RenderError::Rendering(err) => fmt::Debug::fmt(err, f), RenderError::OutputNoMode => f.write_str("Output has no active move"), RenderError::UnmappedOutput => f.write_str("Output was not mapped to this space"), } } }
{ self.outputs.iter() }
Ent_dados.go
package main import "fmt" func main()
{ var nome, cargo, nomechefe string var idade int var salario float64 fmt.Println("Informe seu nome e sua idade:") fmt.Scanln(&nome, &idade) fmt.Println("Certo, agora informe seu cargo e o nome do seu chefe:") fmt.Scanln(&cargo, &nomechefe) fmt.Println("E por último, digite seu ultimo salário:") fmt.Scanln(&salario) fmt.Printf("Os dado informados foram:\nNome: %s\nIdade: %d\nCargo: %s\nNome do chefe: %s\nSalário: %f", nome, idade, cargo, nomechefe, salario) }
widget.py
import numpy as np import pyqtgraph as pg from datetime import datetime, timedelta from vnpy.trader.constant import Interval, Direction, Offset from vnpy.trader.engine import MainEngine from vnpy.trader.ui import QtCore, QtWidgets, QtGui from vnpy.trader.ui.widget import BaseMonitor, BaseCell, DirectionCell, EnumCell from vnpy.trader.ui.editor import CodeEditor from vnpy.event import Event, EventEngine from vnpy.chart import ChartWidget, CandleItem, VolumeItem from vnpy.trader.utility import load_json, save_json from ..engine import ( APP_NAME, EVENT_BACKTESTER_LOG, EVENT_BACKTESTER_BACKTESTING_FINISHED, EVENT_BACKTESTER_OPTIMIZATION_FINISHED, OptimizationSetting ) class BacktesterManager(QtWidgets.QWidget): """""" setting_filename = "cta_backtester_setting.json" signal_log = QtCore.pyqtSignal(Event) signal_backtesting_finished = QtCore.pyqtSignal(Event) signal_optimization_finished = QtCore.pyqtSignal(Event) def __init__(self, main_engine: MainEngine, event_engine: EventEngine): """""" super().__init__() self.main_engine = main_engine self.event_engine = event_engine self.backtester_engine = main_engine.get_engine(APP_NAME) self.class_names = [] self.settings = {} self.target_display = "" self.init_ui() self.register_event() self.backtester_engine.init_engine() self.init_strategy_settings() def init_strategy_settings(self): """""" self.class_names = self.backtester_engine.get_strategy_class_names() for class_name in self.class_names: setting = self.backtester_engine.get_default_setting(class_name) self.settings[class_name] = setting self.class_combo.addItems(self.class_names) def init_ui(self): """""" self.setWindowTitle("CTA回测") # Setting Part self.class_combo = QtWidgets.QComboBox() self.symbol_line = QtWidgets.QLineEdit("IF88.CFFEX") self.interval_combo = QtWidgets.QComboBox() for inteval in Interval: self.interval_combo.addItem(inteval.value) end_dt = datetime.now() start_dt = end_dt - timedelta(days=3 * 365) self.start_date_edit = QtWidgets.QDateEdit( QtCore.QDate( start_dt.year, start_dt.month, start_dt.day ) ) self.end_date_edit = QtWidgets.QDateEdit( QtCore.QDate.currentDate() ) self.rate_line = QtWidgets.QLineEdit("0.000025") self.slippage_line = QtWidgets.QLineEdit("0.2") self.size_line = QtWidgets.QLineEdit("300") self.pricetick_line = QtWidgets.QLineEdit("0.2") self.capital_line = QtWidgets.QLineEdit("1000000") self.inverse_combo = QtWidgets.QComboBox() self.inverse_combo.addItems(["正向", "反向"]) backtesting_button = QtWidgets.QPushButton("开始回测") backtesting_button.clicked.connect(self.start_backtesting) optimization_button = QtWidgets.QPushButton("参数优化") optimization_button.clicked.connect(self.start_optimization) self.result_button = QtWidgets.QPushButton("优化结果") self.result_button.clicked.connect(self.show_optimization_result) self.result_button.setEnabled(False) downloading_button = QtWidgets.QPushButton("下载数据") downloading_button.clicked.connect(self.start_downloading) self.order_button = QtWidgets.QPushButton("委托记录") self.order_button.clicked.connect(self.show_backtesting_orders) self.order_button.setEnabled(False) self.trade_button = QtWidgets.QPushButton("成交记录") self.trade_button.clicked.connect(self.show_backtesting_trades) self.trade_button.setEnabled(False) self.daily_button = QtWidgets.QPushButton("每日盈亏") self.daily_button.clicked.connect(self.show_daily_results) self.daily_button.setEnabled(False) self.candle_button = QtWidgets.QPushButton("K线图表") self.candle_button.clicked.connect(self.show_candle_chart) self.candle_button.setEnabled(False) edit_button = QtWidgets.QPushButton("代码编辑") edit_button.clicked.connect(self.edit_strategy_code) reload_button = QtWidgets.QPushButton("策略重载") reload_button.clicked.connect(self.reload_strategy_class) for button in [ backtesting_button, optimization_button, downloading_button, self.result_button, self.order_button, self.trade_button, self.daily_button, self.candle_button, edit_button, reload_button ]: button.setFixedHeight(button.sizeHint().height() * 2) form = QtWidgets.QFormLayout() form.addRow("交易策略", self.class_combo) form.addRow("本地代码", self.symbol_line) form.addRow("K线周期", self.interval_combo) form.addRow("开始日期", self.start_date_edit) form.addRow("结束日期", self.end_date_edit) form.addRow("手续费率", self.rate_line) form.addRow("交易滑点", self.slippage_line) form.addRow("合约乘数", self.size_line) form.addRow("价格跳动", self.pricetick_line) form.addRow("回测资金", self.capital_line) form.addRow("合约模式", self.inverse_combo) result_grid = QtWidgets.QGridLayout() result_grid.addWidget(self.trade_button, 0, 0) result_grid.addWidget(self.order_button, 0, 1) result_grid.addWidget(self.daily_button, 1, 0) result_grid.addWidget(self.candle_button, 1, 1) left_vbox = QtWidgets.QVBoxLayout() left_vbox.addLayout(form) left_vbox.addWidget(backtesting_button) left_vbox.addWidget(downloading_button) left_vbox.addStretch() left_vbox.addLayout(result_grid) left_vbox.addStretch() left_vbox.addWidget(optimization_button) left_vbox.addWidget(self.result_button) left_vbox.addStretch() left_vbox.addWidget(edit_button) left_vbox.addWidget(reload_button) # Result part self.statistics_monitor = StatisticsMonitor() self.log_monitor = QtWidgets.QTextEdit() self.log_monitor.setMaximumHeight(400) self.chart = BacktesterChart() self.chart.setMinimumWidth(1000) self.trade_dialog = BacktestingResultDialog( self.main_engine, self.event_engine, "回测成交记录", BacktestingTradeMonitor ) self.order_dialog = BacktestingResultDialog( self.main_engine, self.event_engine, "回测委托记录", BacktestingOrderMonitor ) self.daily_dialog = BacktestingResultDialog( self.main_engine, self.event_engine, "回测每日盈亏", DailyResultMonitor ) # Candle Chart self.candle_dialog = CandleChartDialog() # Layout vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.statistics_monitor) vbox.addWidget(self.log_monitor) hbox = QtWidgets.QHBoxLayout() hbox.addLayout(left_vbox) hbox.addLayout(vbox) hbox.addWidget(self.chart) self.setLayout(hbox) # Code Editor self.editor = CodeEditor(self.main_engine, self.event_engine) # Load setting setting = load_json(self.setting_filename) if not setting: return self.class_combo.setCurrentIndex( self.class_combo.findText(setting["class_name"]) ) self.symbol_line.setText(setting["vt_symbol"]) self.interval_combo.setCurrentIndex( self.interval_combo.findText(setting["interval"]) ) self.rate_line.setText(str(setting["rate"])) self.slippage_line.setText(str(setting["slippage"])) self.size_line.setText(str(setting["size"])) self.pricetick_line.setText(str(setting["pricetick"])) self.capital_line.setText(str(setting["capital"])) if not setting["inverse"]: self.inverse_combo.setCurrentIndex(0) else: self.inverse_combo.setCurrentIndex(1) def register_event(self): """""" self.signal_log.connect(self.process_log_event) self.signal_backtesting_finished.connect( self.process_backtesting_finished_event) self.signal_optimization_finished.connect( self.process_optimization_finished_event) self.event_engine.register(EVENT_BACKTESTER_LOG, self.signal_log.emit) self.event_engine.register( EVENT_BACKTESTER_BACKTESTING_FINISHED, self.signal_backtesting_finished.emit) self.event_engine.register( EVENT_BACKTESTER_OPTIMIZATION_FINISHED, self.signal_optimization_finished.emit) def process_log_event(self, event: Event): """""" msg = event.data self.write_log(msg) def write_log(self, msg): """""" timestamp = datetime.now().strftime("%H:%M:%S") msg = f"{timestamp}\t{msg}" self.log_monitor.append(msg) def process_backtesting_finished_event(self, event: Event): """""" statistics = self.backtester_engine.get_result_statistics() self.statistics_monitor.set_data(statistics) df = self.backtester_engine.get_result_df() self.chart.set_data(df) self.trade_button.setEnabled(True) self.order_button.setEnabled(True) self.daily_button.setEnabled(True) self.candle_button.setEnabled(True) def process_optimization_finished_event(self, event: Event): """""" self.write_log("请点击[优化结果]按钮查看") self.result_button.setEnabled(True) def start_backtesting(self): """""" class_name = self.class_combo.currentText() vt_symbol = self.symbol_line.text() interval = self.interval_combo.currentText() start = self.start_date_edit.date().toPyDate() end = self.end_date_edit.date().toPyDate() rate = float(self.rate_line.text()) slippage = float(self.slippage_line.text()) size = float(self.size_line.text()) pricetick = float(self.pricetick_line.text()) capital = float(self.capital_line.text()) if self.inverse_combo.currentText() == "正向": inverse = False else: inverse = True # Save backtesting parameters backtesting_setting = { "class_name": class_name, "vt_symbol": vt_symbol, "interval": interval, "rate": rate, "slippage": slippage, "size": size, "pricetick": pricetick, "capital": capital, "inverse": inverse, } save_json(self.setting_filename, backtesting_setting) # Get strategy setting old_setting = self.settings[class_name] dialog = BacktestingSettingEditor(class_name, old_setting) i = dialog.exec() if i != dialog.Accepted: return new_setting = dialog.get_setting() self.settings[class_name] = new_setting result = self.backtester_engine.start_backtesting( class_name, vt_symbol, interval, start, end, rate, slippage, size, pricetick, capital, inverse, new_setting ) if result: self.statistics_monitor.clear_data() self.chart.clear_data() self.trade_button.setEnabled(False) self.order_button.setEnabled(False) self.daily_button.setEnabled(False) self.candle_button.setEnabled(False) self.trade_dialog.clear_data() self.order_dialog.clear_data() self.daily_dialog.clear_data() self.candle_dialog.clear_data() def start_optimization(self): """""" class_name = self.class_combo.currentText() vt_symbol = self.symbol_line.text() interval = self.interval_combo.currentText() start = self.start_date_edit.date().toPyDate() end = self.end_date_edit.date().toPyDate() rate = float(self.rate_line.text()) slippage = float(self.slippage_line.text()) size = float(self.size_line.text()) pricetick = float(self.pricetick_line.text()) capital = float(self.capital_line.text()) if self.inverse_combo.currentText() == "正向": inverse = False else: inverse = True parameters = self.settings[class_name] dialog = OptimizationSettingEditor(class_name, parameters) i = dialog.exec() if i != dialog.Accepted: return optimization_setting, use_ga = dialog.get_setting() self.target_display = dialog.target_display self.backtester_engine.start_optimization( class_name, vt_symbol, interval, start, end, rate, slippage, size, pricetick, capital, inverse, optimization_setting, use_ga ) self.result_button.setEnabled(False) def start_downloading(self): """""" vt_symbol = self.symbol_line.text() interval = self.interval_combo.currentText() start_date = self.start_date_edit.date() end_date = self.end_date_edit.date() start = datetime(start_date.year(), start_date.month(), start_date.day()) end = datetime(end_date.year(), end_date.month(), end_date.day(), 23, 59, 59) self.backtester_engine.start_downloading( vt_symbol, interval, start, end ) def show_optimization_result(self): """""" result_values = self.backtester_engine.get_result_values() dialog = OptimizationResultMonitor( result_values, self.target_display ) dialog.exec_() def show_backtesting_trades(self): """""" if not self.trade_dialog.is_updated(): trades = self.backtester_engine.get_all_trades() self.trade_dialog.update_data(trades) self.trade_dialog.exec_() def show_backtesting_orders(self): """""" if not self.order_dialog.is_updated(): orders = self.backtester_engine.get_all_orders() self.order_dialog.update_data(orders) self.order_dialog.exec_() def show_daily_results(self): """""" if not self.daily_dialog.is_updated(): results = self.backtester_engine.get_all_daily_results() self.daily_dialog.update_data(results) self.daily_dialog.exec_() def show_candle_chart(self): """""" if not self.candle_dialog.is_updated(): history = self.backtester_engine.get_history_data() self.candle_dialog.update_history(history) trades = self.backtester_engine.get_all_trades() self.candle_dialog.update_trades(trades) self.candle_dialog.exec_() def edit_strategy_code(self): """""" class_name = self.class_combo.currentText() file_path = self.backtester_engine.get_strategy_class_file(class_name) self.editor.open_editor(file_path) self.editor.show() def reload_strategy_class(self): """""" self.backtester_engine.reload_strategy_class() self.class_combo.clear() self.init_strategy_settings() def show(self): """""" self.showMaximized() class StatisticsMonitor(QtWidgets.QTableWidget): """""" KEY_NAME_MAP = { "start_date": "首个交易日", "end_date": "最后交易日", "total_days": "总交易日", "profit_days": "盈利交易日", "loss_days": "亏损交易日", "capital": "起始资金", "end_balance": "结束资金", "total_return": "总收益率", "annual_return": "年化收益", "max_drawdown": "最大回撤", "max_ddpercent": "百分比最大回撤", "total_net_pnl": "总盈亏", "total_commission": "总手续费", "total_slippage": "总滑点", "total_turnover": "总成交额", "total_trade_count": "总成交笔数", "daily_net_pnl": "日均盈亏", "daily_commission": "日均手续费", "daily_slippage": "日均滑点", "daily_turnover": "日均成交额", "daily_trade_count": "日均成交笔数", "daily_return": "日均收益率", "return_std": "收益标准差", "sharpe_ratio": "夏普比率", "return_drawdown_ratio": "收益回撤比" } def __init__(self): """""" super().__init__() self.cells = {} self.init_ui() def init_ui(self): """""" self.setRowCount(len(self.KEY_NAME_MAP)) self.setVerticalHeaderLabels(list(self.KEY_NAME_MAP.values())) self.setColumnCount(1) self.horizontalHeader().setVisible(False) self.horizontalHeader().setSectionResizeMode( QtWidgets.QHeaderView.Stretch ) self.setEditTriggers(self.NoEditTriggers) for row, key in enumerate(self.KEY_NAME_MAP.keys()): cell = QtWidgets.QTableWidgetItem() self.setItem(row, 0, cell) self.cells[key] = cell def clear_data(self): """""" for cell in self.cells.values(): cell.setText("") def set_data(self, data: dict): """""" data["capital"] = f"{data['capital']:,.2f}" data["end_balance"] = f"{data['end_balance']:,.2f}" data["total_return"] = f"{data['total_return']:,.2f}%" data["annual_return"] = f"{data['annual_return']:,.2f}%" data["max_drawdown"] = f"{data['max_drawdown']:,.2f}" data["max_ddpercent"] = f"{data['max_ddpercent']:,.2f}%" data["total_net_pnl"] = f"{data['total_net_pnl']:,.2f}" data["total_commission"] = f"{data['total_commission']:,.2f}" data["total_slippage"] = f"{data['total_slippage']:,.2f}" data["total_turnover"] = f"{data['total_turnover']:,.2f}" data["daily_net_pnl"] = f"{data['daily_net_pnl']:,.2f}" data["daily_commission"] = f"{data['daily_commission']:,.2f}" data["daily_slippage"] = f"{data['daily_slippage']:,.2f}" data["daily_turnover"] = f"{data['daily_turnover']:,.2f}" data["daily_return"] = f"{data['daily_return']:,.2f}%" data["return_std"] = f"{data['return_std']:,.2f}%" data["sharpe_ratio"] = f"{data['sharpe_ratio']:,.2f}" data["return_drawdown_ratio"] = f"{data['return_drawdown_ratio']:,.2f}" for key, cell in self.cells.items(): value = data.get(key, "") cell.setText(str(value)) class BacktestingSettingEditor(QtWidgets.QDialog): """ For creating new strategy and editing strategy parameters. """ def __init__( self, class_name: str, parameters: dict ): """""" super(BacktestingSettingEditor, self).__init__() self.class_name = class_name self.parameters = parameters self.edits = {} self.init_ui() def init_ui(self): """""" form = QtWidgets.QFormLayout() # Add vt_symbol and name edit if add new strategy self.setWindowTitle(f"策略参数配置:{self.class_name}") button_text = "确定" parameters = self.parameters for name, value in parameters.items(): type_ = type(value) edit = QtWidgets.QLineEdit(str(value)) if type_ is int: validator = QtGui.QIntValidator() edit.setValidator(validator) elif type_ is float: validator = QtGui.QDoubleValidator() edit.setValidator(validator) form.addRow(f"{name} {type_}", edit) self.edits[name] = (edit, type_) button = QtWidgets.QPushButton(button_text) button.clicked.connect(self.accept) form.addRow(button) self.setLayout(form) def get_setting(self): """""" setting = {} for name, tp in self.edits.items(): edit, type_ = tp value_text = edit.text() if type_ == bool: if value_text == "True": value = True else: value = False else: value = type_(value_text) setting[name] = value return setting class BacktesterChart(pg.GraphicsWindow): """""" def __init__(self): """""" super().__init__(title="Backtester Chart") self.dates = {} self.init_ui() def init_ui(self): """""" pg.setConfigOptions(antialias=True) # Create plot widgets self.balance_plot = self.addPlot( title="账户净值", axisItems={"bottom": DateAxis(self.dates, orientation="bottom")} ) self.nextRow() self.drawdown_plot = self.addPlot( title="净值回撤", axisItems={"bottom": DateAxis(self.dates, orientation="bottom")} ) self.nextRow() self.pnl_plot = self.addPlot( title="每日盈亏", axisItems={"bottom": DateAxis(self.dates, orientation="bottom")} ) self.nextRow() self.distribution_plot = self.addPlot(title="盈亏分布") # Add curves and bars on plot widgets self.balance_curve = self.balance_plot.plot( pen=pg.mkPen("#ffc107", width=3) ) dd_color = "#303f9f" self.drawdown_curve = self.drawdown_plot.plot( fillLevel=-0.3, brush=dd_color, pen=dd_color ) profit_color = 'r' loss_color = 'g' self.profit_pnl_bar = pg.BarGraphItem( x=[], height=[], width=0.3, brush=profit_color, pen=profit_color ) self.loss_pnl_bar = pg.BarGraphItem( x=[], height=[], width=0.3, brush=loss_color, pen=loss_color ) self.pnl_plot.addItem(self.profit_pnl_bar) self.pnl_plot.addItem(self.loss_pnl_bar) distribution_color = "#6d4c41" self.distribution_curve = self.distribution_plot.plot( fillLevel=-0.3, brush=distribution_color, pen=distribution_color ) def clear_data(self): """""" self.balance_curve.setData([], []) self.drawdown_curve.setData([], []) self.profit_pnl_bar.setOpts(x=[], height=[]) self.loss_pnl_bar.setOpts(x=[], height=[]) self.distribution_curve.setData([], []) def set_data(self, df): """""" if df is None: return count = len(df) self.dates.clear() for n, date in enumerate(df.index): self.dates[n] = date # Set data for curve of balance and drawdown self.balance_curve.setData(df["balance"]) self.drawdown_curve.setData(df["drawdown"]) # Set data for daily pnl bar profit_pnl_x = [] profit_pnl_height = [] loss_pnl_x = [] loss_pnl_height = [] for count, pnl in enumerate(df["net_pnl"]): if pnl >= 0: profit_pnl_height.append(pnl) profit_pnl_x.append(count) else: loss_pnl_height.append(pnl) loss_pnl_x.append(count) self.profit_pnl_bar.setOpts(x=profit_pnl_x, height=profit_pnl_height) self.loss_pnl_bar.setOpts(x=loss_pnl_x, height=loss_pnl_height) # Set data for pnl distribution hist, x = np.histogram(df["net_pnl"], bins="auto") x = x[:-1] self.distribution_curve.setData(x, hist) class DateAxis(pg.AxisItem): """Axis for showing date data""" def __init__(self, dates: dict, *args, **kwargs): """""" super().__init__(*args, **kwargs) self.dates = dates def tickStrings(self, values, scale, spacing): """""" strings = [] for v in values: dt = self.dates.get(v, "") strings.append(str(dt)) return strings class OptimizationSettingEditor(QtWidgets.QDialog): """ For setting up parameters for optimization. """ DISPLAY_NAME_MAP = { "总收益率": "total_return", "夏普比率": "sharpe_ratio", "收益回撤比": "return_drawdown_ratio", "日均盈亏": "daily_net_pnl" } def __init__( self, class_name: str, parameters: dict ): """""" super().__init__() self.class_name = class_name self.parameters = parameters self.edits = {} self.optimization_setting = None self.use_ga = False self.init_ui() def init_ui(self): """""" QLabel = QtWidgets.QLabel self.target_combo = QtWidgets.QComboBox() self.target_combo.addItems(list(self.DISPLAY_NAME_MAP.keys())) grid = QtWidgets.QGridLayout() grid.addWidget(QLabel("目标"), 0, 0) grid.addWidget(self.target_combo, 0, 1, 1, 3) grid.addWidget(QLabel("参数"), 1, 0) grid.addWidget(QLabel("开始"), 1, 1) grid.addWidget(QLabel("步进"), 1, 2) grid.addWidget(QLabel("结束"), 1, 3) # Add vt_symbol and name edit if add new strategy self.setWindowTitle(f"优化参数配置:{self.class_name}") validator = QtGui.QDoubleValidator() row = 2 for name, value in self.parameters.items(): type_ = type(value) if type_ not in [int, float]: continue start_edit = QtWidgets.QLineEdit(str(value)) step_edit = QtWidgets.QLineEdit(str(1)) end_edit = QtWidgets.QLineEdit(str(value)) for edit in [start_edit, step_edit, end_edit]: edit.setValidator(validator) grid.addWidget(QLabel(name), row, 0) grid.addWidget(start_edit, row, 1) grid.addWidget(step_edit, row, 2) grid.addWidget(end_edit, row, 3) self.edits[name] = { "type": type_, "start": start_edit, "step": step_edit, "end": end_edit } row += 1 parallel_button = QtWidgets.QPushButton("多进程优化") parallel_button.clicked.connect(self.generate_parallel_setting) grid.addWidget(parallel_button, row, 0, 1, 4) row += 1 ga_button = QtWidgets.QPushButton("遗传算法优化") ga_button.clicked.connect(self.generate_ga_setting) grid.addWidget(ga_button, row, 0, 1, 4) self.setLayout(grid) def generate_ga_setting(self): """""" self.use_ga = True self.generate_setting() def generate_parallel_setting(self): """""" self.use_ga = False self.generate_setting() def generate_setting(self): """""" self.optimization_setting = OptimizationSetting() self.target_display = self.target_combo.currentText() target_name = self.DISPLAY_NAME_MAP[self.target_display] self.optimization_setting.set_target(target_name) for name, d in self.edits.items(): type_ = d["type"] start_value = type_(d["start"].text()) step_value = type_(d["step"].text()) end_value = type_(d["end"].text()) if start_value == end_value: self.optimization_setting.add_parameter(name, start_value) else: self.optimization_setting.add_parameter( name, start_value, end_value, step_value ) self.accept() def get_setting(self): """""" return self.optimization_setting, self.use_ga class OptimizationResultMonitor(QtWidgets.QDialog): """ For viewing optimization result. """ def __init__( self, result_values: list, target_display: str ): """""" super().__init__() self.result_values = result_values self.target_display = target_display self.init_ui() def init_ui(self): """""" self.setWindowTitle("参数优化结果") self.resize(1100, 500) table = QtWidgets.QTableWidget() table.setColumnCount(2) table.setRowCount(len(self.result_values)) table.setHorizontalHeaderLabels(["参数", self.target_display]) table.setEdi
date": False}, "volume": {"display": "数量", "cell": BaseCell, "update": False}, "datetime": {"display": "时间", "cell": BaseCell, "update": False}, "gateway_name": {"display": "接口", "cell": BaseCell, "update": False}, } class BacktestingOrderMonitor(BaseMonitor): """ Monitor for backtesting order data. """ headers = { "orderid": {"display": "委托号", "cell": BaseCell, "update": False}, "symbol": {"display": "代码", "cell": BaseCell, "update": False}, "exchange": {"display": "交易所", "cell": EnumCell, "update": False}, "type": {"display": "类型", "cell": EnumCell, "update": False}, "direction": {"display": "方向", "cell": DirectionCell, "update": False}, "offset": {"display": "开平", "cell": EnumCell, "update": False}, "price": {"display": "价格", "cell": BaseCell, "update": False}, "volume": {"display": "总数量", "cell": BaseCell, "update": False}, "traded": {"display": "已成交", "cell": BaseCell, "update": False}, "status": {"display": "状态", "cell": EnumCell, "update": False}, "datetime": {"display": "时间", "cell": BaseCell, "update": False}, "gateway_name": {"display": "接口", "cell": BaseCell, "update": False}, } class DailyResultMonitor(BaseMonitor): """ Monitor for backtesting daily result. """ headers = { "date": {"display": "日期", "cell": BaseCell, "update": False}, "trade_count": {"display": "成交笔数", "cell": BaseCell, "update": False}, "start_pos": {"display": "开盘持仓", "cell": BaseCell, "update": False}, "end_pos": {"display": "收盘持仓", "cell": BaseCell, "update": False}, "turnover": {"display": "成交额", "cell": BaseCell, "update": False}, "commission": {"display": "手续费", "cell": BaseCell, "update": False}, "slippage": {"display": "滑点", "cell": BaseCell, "update": False}, "trading_pnl": {"display": "交易盈亏", "cell": BaseCell, "update": False}, "holding_pnl": {"display": "持仓盈亏", "cell": BaseCell, "update": False}, "total_pnl": {"display": "总盈亏", "cell": BaseCell, "update": False}, "net_pnl": {"display": "净盈亏", "cell": BaseCell, "update": False}, } class BacktestingResultDialog(QtWidgets.QDialog): """ """ def __init__( self, main_engine: MainEngine, event_engine: EventEngine, title: str, table_class: QtWidgets.QTableWidget ): """""" super().__init__() self.main_engine = main_engine self.event_engine = event_engine self.title = title self.table_class = table_class self.updated = False self.init_ui() def init_ui(self): """""" self.setWindowTitle(self.title) self.resize(1100, 600) self.table = self.table_class(self.main_engine, self.event_engine) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.table) self.setLayout(vbox) def clear_data(self): """""" self.updated = False self.table.setRowCount(0) def update_data(self, data: list): """""" self.updated = True data.reverse() for obj in data: self.table.insert_new_row(obj) def is_updated(self): """""" return self.updated class CandleChartDialog(QtWidgets.QDialog): """ """ def __init__(self): """""" super().__init__() self.dt_ix_map = {} self.updated = False self.init_ui() def init_ui(self): """""" self.setWindowTitle("回测K线图表") self.resize(1400, 800) # Create chart widget self.chart = ChartWidget() self.chart.add_plot("candle", hide_x_axis=True) self.chart.add_plot("volume", maximum_height=200) self.chart.add_item(CandleItem, "candle", "candle") self.chart.add_item(VolumeItem, "volume", "volume") self.chart.add_cursor() # Add scatter item for showing tradings self.trade_scatter = pg.ScatterPlotItem() candle_plot = self.chart.get_plot("candle") candle_plot.addItem(self.trade_scatter) # Set layout vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.chart) self.setLayout(vbox) def update_history(self, history: list): """""" self.updated = True self.chart.update_history(history) for ix, bar in enumerate(history): self.dt_ix_map[bar.datetime] = ix def update_trades(self, trades: list): """""" trade_data = [] for trade in trades: ix = self.dt_ix_map[trade.datetime] scatter = { "pos": (ix, trade.price), "data": 1, "size": 14, "pen": pg.mkPen((255, 255, 255)) } if trade.direction == Direction.LONG: scatter_symbol = "t1" # Up arrow else: scatter_symbol = "t" # Down arrow if trade.offset == Offset.OPEN: scatter_brush = pg.mkBrush((255, 255, 0)) # Yellow else: scatter_brush = pg.mkBrush((0, 0, 255)) # Blue scatter["symbol"] = scatter_symbol scatter["brush"] = scatter_brush trade_data.append(scatter) self.trade_scatter.setData(trade_data) def clear_data(self): """""" self.updated = False self.chart.clear_all() self.dt_ix_map.clear() self.trade_scatter.clear() def is_updated(self): """""" return self.updated
tTriggers(table.NoEditTriggers) table.verticalHeader().setVisible(False) table.horizontalHeader().setSectionResizeMode( 0, QtWidgets.QHeaderView.ResizeToContents ) table.horizontalHeader().setSectionResizeMode( 1, QtWidgets.QHeaderView.Stretch ) for n, tp in enumerate(self.result_values): setting, target_value, _ = tp setting_cell = QtWidgets.QTableWidgetItem(str(setting)) target_cell = QtWidgets.QTableWidgetItem(str(target_value)) setting_cell.setTextAlignment(QtCore.Qt.AlignCenter) target_cell.setTextAlignment(QtCore.Qt.AlignCenter) table.setItem(n, 0, setting_cell) table.setItem(n, 1, target_cell) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(table) self.setLayout(vbox) class BacktestingTradeMonitor(BaseMonitor): """ Monitor for backtesting trade data. """ headers = { "tradeid": {"display": "成交号 ", "cell": BaseCell, "update": False}, "orderid": {"display": "委托号", "cell": BaseCell, "update": False}, "symbol": {"display": "代码", "cell": BaseCell, "update": False}, "exchange": {"display": "交易所", "cell": EnumCell, "update": False}, "direction": {"display": "方向", "cell": DirectionCell, "update": False}, "offset": {"display": "开平", "cell": EnumCell, "update": False}, "price": {"display": "价格", "cell": BaseCell, "up
ExampleAppBankIdLogin.tsx
import * as React from "react";
Text, View, WebView, } from "react-native"; import { NavigationScreenProp } from "react-navigation"; import { connect } from "react-redux"; import { bindActionCreators, Dispatch } from "redux"; import { RequestSSOTokenFromApi, requestSSOTokenFromApiAction, SSOTokenAction, } from "../../actions/sso-token"; import { BANK_ID_REDIRECT_PATH } from "../../constants/bank-id"; import { IAppConfigState } from "../../types/app-config"; import { ISSOTokenState } from "../../types/sso-token"; import { IStoreState } from "../../types/store"; interface IComponentProps { navigation: NavigationScreenProp<any, any>; } interface IStateToProps { ssoToken: ISSOTokenState; appConfig: IAppConfigState; } interface IDispatchToProps { requestSSOTokenFromApi: RequestSSOTokenFromApi; } type Props = IComponentProps & IStateToProps & IDispatchToProps; class ExampleAppBankIdLogin extends React.Component<Props> { public static navigationOptions = { headerBackTitle: null, title: "BankID login", }; public handleNavigationStateChanged = (navState: NavState): void => { const { ssoToken, requestSSOTokenFromApi, appConfig } = this.props; if (navState.url === `${appConfig.environment}/${BANK_ID_REDIRECT_PATH}`) { if (!ssoToken.isFetching && !ssoToken.data && !ssoToken.error) { requestSSOTokenFromApi(); } } } public render() { const { ssoToken, navigation, appConfig } = this.props; if (ssoToken.isFetching) { return ( <View style={styles.container}> <Text>Fetching token...</Text> </View> ); } return ( <WebView source={{ uri: `${appConfig.environment}/${navigation.state.params.path}` }} style={styles.container} onNavigationStateChange={this.handleNavigationStateChanged} startInLoadingState={true} /> ); } } const styles = StyleSheet.create({ container: { alignItems: "center", backgroundColor: "#fffffa", flex: 1, justifyContent: "center", }, }); const mapStateToProps = (state: IStoreState) => ({ appConfig: state.appConfig, ssoToken: state.ssoToken, }); const mapDispatchToProps = (dispatch: Dispatch<SSOTokenAction>) => bindActionCreators({ requestSSOTokenFromApi: requestSSOTokenFromApiAction, }, dispatch); export default connect<IStateToProps, IDispatchToProps>( mapStateToProps, mapDispatchToProps, )(ExampleAppBankIdLogin);
import { NavState, StyleSheet,
lexer.rs
/* * Copyright (c) Facebook, Inc. and its affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. */ use crate::char_constants::*; use crate::lexer_position::LexerPosition; use crate::syntax_node::Token; use crate::token_kind::TokenKind; use common::Span; /// Lexer for the *executable* subset of the GraphQL specification: /// https://github.com/graphql/graphql-spec/blob/master/spec/Appendix%20B%20--%20Grammar%20Summary.md /// /// Lazily transforms a source str into a sequence of `Token`s that encode /// leading trivia, a kind, trailing trivia, and spans that exclude the trivia. #[derive(Clone, Debug)] pub struct Lexer<'a> { position: LexerPosition<'a>, } impl<'a> Lexer<'a> { pub fn new(source: &'a str) -> Self { Lexer { position: LexerPosition::new(source), } } /// Advance the lexer and return the next token. pub fn next(&mut self) -> Token { self.skip_leading_trivia(); let start = self.position.index(); let kind = self.next_kind(); let span = Span::from_usize(start, self.position.index() - start); self.skip_trailing_trivia(); Token { kind, span } } fn peek(&self) -> TokenKind { let mut clone = self.clone(); clone.next_kind() } fn next_kind(&mut self) -> TokenKind { let ch = self.position.next(); match ch { LINE_FEED => TokenKind::NewLine, CARRIAGE_RETURN => { self.position.eat(LINE_FEED); TokenKind::NewLine } TAB | SPACE => { self.position.skip_while(is_non_newline_whitespace); TokenKind::Whitespace } AT => TokenKind::At, CLOSE_BRACE => TokenKind::CloseBrace, CLOSE_BRACKET => TokenKind::CloseBracket, CLOSE_PAREN => TokenKind::CloseParen, COLON => TokenKind::Colon, COMMA => TokenKind::Comma, DOUBLE_QUOTE => self.lex_string_literal_rest(), EQUALS => TokenKind::Equals, EXCLAMATION => TokenKind::Exclamation, HASH => self.lex_comment(), NULL => TokenKind::EndOfFile, OPEN_BRACE => TokenKind::OpenBrace, OPEN_BRACKET => TokenKind::OpenBracket, OPEN_PAREN => TokenKind::OpenParen, PIPE => TokenKind::Pipe, PERIOD => { // It's invalid to have anything other than exactly '...', but since period // has no other meaning we can recover in the parser. let peek = self.position.peek(); if peek == PERIOD { self.position.next(); if self.position.peek() == PERIOD { self.position.next(); TokenKind::Spread } else { TokenKind::PeriodPeriod } } else if is_digit(peek) { self.position.next(); self.lex_number_error() } else { TokenKind::Period } } DOLLAR => self.lex_variable_identifier_rest(), MINUS => self.lex_number_literal_rest(ch), PLUS => self.lex_number_error(), ch if is_digit(ch) => self.lex_number_literal_rest(ch), ch if is_identifier_start(ch) => self.lex_identifer_rest(), _ => self.lex_error(), } } /// Skips over all insignificant tokens (including newlines) up to the start of /// the next significant token, fn skip_leading_trivia(&mut self) { let mut clone = self.clone(); loop { match clone.peek() { TokenKind::NewLine | TokenKind::SingleLineComment | TokenKind::Whitespace | TokenKind::Comma => { // intentionally ignore since we know the result is valid let _ = clone.next_kind(); } _ => { self.position = clone.position; break; } } } } /// Skips over all insigificant tokens up to the next newline fn skip_trailing_trivia(&mut self) { let mut clone = self.clone(); loop { match clone.peek() { TokenKind::SingleLineComment | TokenKind::Whitespace | TokenKind::Comma => { // intentionally ignore since we know the result is valid let _ = clone.next_kind(); } _ => { self.position = clone.position; break; } } } } /// Skips any remaining invalid tokens (expected to be called after /// encountering the first invalid token), recording the error details /// and returning a token error. fn lex_error(&mut self) -> TokenKind { let mut position = self.position.clone(); loop { match position.peek() { LINE_FEED | CARRIAGE_RETURN | TAB | SPACE | AT | CLOSE_BRACE | CLOSE_BRACKET | CLOSE_PAREN | COLON | COMMA | DOUBLE_QUOTE | EQUALS | EXCLAMATION | HASH | MINUS | NULL | OPEN_BRACE | OPEN_BRACKET | OPEN_PAREN | PIPE | PLUS | PERIOD | DOLLAR => break, ch => { if is_digit(ch) || is_identifier_start(ch) { break; } else { position.next(); // consume the invalid char continue; } } }; } self.position = position; TokenKind::ErrorUnsupportedCharacterSequence } /// Skips any remaining number-like characters (digits, period, plus/minus, exponent, or /// identifier). fn lex_number_error(&mut self) -> TokenKind { let mut position = self.position.clone(); loop { let ch = position.peek(); match ch { PERIOD | PLUS | MINUS => { position.next(); continue; } _ => { if is_digit(ch) || is_identifier_start(ch) { position.next(); continue; } else { break; } } }; } self.position = position; TokenKind::ErrorUnsupportedNumberLiteral } /// Comment :: # CommentChar* /// /// CommentChar :: SourceCharacter but not LineTerminator fn lex_comment(&mut self) -> TokenKind { loop { match self.position.peek() { LINE_FEED | CARRIAGE_RETURN | NULL => return TokenKind::SingleLineComment, _ => { self.position.next(); } } } } /// Lexes the remainder of an identifer (after the leading '$' char). /// /// Variable : $ Name fn lex_variable_identifier_rest(&mut self) -> TokenKind { if !is_identifier_start(self.position.peek()) { TokenKind::ErrorInvalidVariableIdentifier } else { self.position.next(); // skip identifier start self.position.skip_while(is_identifer_part); TokenKind::VariableIdentifier } } /// Lexes the remainder of an identifer (after the first char). /// /// Name :: /[_A-Za-z][_0-9A-Za-z]*/ fn lex_identifer_rest(&mut self) -> TokenKind { self.position.skip_while(is_identifer_part); TokenKind::Identifier } /// Lexes the remainder of a string literal (after the leading double quote) /// /// StringValue :: /// " StringCharacter* " /// """ BlockStringCharacter* """ /// /// StringCharacter :: /// SourceCharacter but not " or \ or LineTerminator /// \u EscapedUnicode /// \ EscapedCharacter /// /// EscapedUnicode :: /[0-9A-Fa-f]{4}/ /// /// EscapedCharacter :: one of " \ / b f n r t /// /// BlockStringCharacter :: /// SourceCharacter but not """ or \""" /// \""" /// Note: Block string values are interpreted to exclude blank initial and trailing lines and uniform indentation with {BlockStringValue()}. /// /// SourceCharacter :: /[\u0009\u000A\u000D\u0020-\uFFFF]/ fn
(&mut self) -> TokenKind { // TODO T60450344: full string literal support if self.position.peek() == DOUBLE_QUOTE && self.position.peek_offset(1) == DOUBLE_QUOTE { unimplemented!("TODO T60450344: support for triple-quoted strings") } loop { match self.position.next() { NULL => { return TokenKind::ErrorUnterminatedStringLiteral; } BACKSLASH => match self.position.next() { '"' | '\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' => continue, 'u' => unimplemented!("TODO T60450344: handle unicode escape sequence"), NULL => { return TokenKind::ErrorUnterminatedStringLiteral; } ch => unimplemented!("TODO T60450344: handle unknown escape sequence {:?}", ch), }, DOUBLE_QUOTE => return TokenKind::StringLiteral, _ => continue, } } } /// Lexes the remainder of a number, after consuming the provided character /// /// IntValue :: IntegerPart /// /// IntegerPart :: /// NegativeSign? 0 /// NegativeSign? NonZeroDigit Digit* /// /// NegativeSign :: - /// /// Digit :: one of 0 1 2 3 4 5 6 7 8 9 /// /// NonZeroDigit :: Digit but not 0 /// /// FloatValue :: /// IntegerPart FractionalPart /// IntegerPart ExponentPart /// IntegerPart FractionalPart ExponentPart /// /// FractionalPart :: . Digit+ /// /// ExponentPart :: ExponentIndicator Sign? Digit+ /// /// ExponentIndicator :: one of e E /// /// Sign :: one of + - /// fn lex_number_literal_rest(&mut self, consumed_ch: char) -> TokenKind { let mut ch = consumed_ch; let mut is_float = false; if ch == MINUS { ch = self.position.next(); } if ch == DIGIT_0 { ch = self.position.peek(); if is_digit(ch) { return self.lex_number_error(); } } else if is_digit(ch) { // Skip any additional digits self.position.skip_while(is_digit); ch = self.position.peek(); } else { return self.lex_number_error(); } if ch == PERIOD { self.position.next(); // Consume the period is_float = true; if self.read_digits().is_err() { return self.lex_number_error(); } ch = self.position.peek(); } if ch == CHAR_E || ch == CHAR_LOWER_E { is_float = true; self.position.next(); // Consume the E ch = self.position.peek(); if ch == MINUS || ch == PLUS { self.position.next(); // Consume the sign } if self.read_digits().is_err() { return self.lex_number_error(); } ch = self.position.peek(); } if ch == PERIOD || is_identifier_start(ch) { return self.lex_number_error(); } if is_float { TokenKind::FloatLiteral } else { TokenKind::IntegerLiteral } } /// Consumes all consecutive digits, or errors if the next character is not a digit. fn read_digits(&mut self) -> Result<(), ()> { let ch = self.position.peek(); if !is_digit(ch) { Err(()) } else { self.position.skip_while(is_digit); Ok(()) } } } fn is_digit(ch: char) -> bool { ch >= DIGIT_0 && ch <= DIGIT_9 } fn is_identifier_start(ch: char) -> bool { (ch >= CHAR_A && ch <= CHAR_Z) || (ch >= CHAR_LOWER_A && ch <= CHAR_LOWER_Z) || ch == UNDERSCORE } fn is_identifer_part(ch: char) -> bool { is_identifier_start(ch) || is_digit(ch) } fn is_non_newline_whitespace(ch: char) -> bool { match ch { SPACE | TAB | VERTICAL_TAB | FORM_FEED => true, _ => false, } } #[allow(dead_code)] fn is_newline(ch: char) -> bool { match ch { LINE_FEED | CARRIAGE_RETURN | LINE_SEPARATOR | PARAGRAPH_SEPARATOR => true, _ => false, } } #[cfg(test)] mod tests { use super::*; macro_rules! assert_token { ($src:expr, $kind:expr, $start:expr, $length:expr) => { assert_eq!( Lexer::new($src).next(), $crate::syntax_node::Token { span: Span::new($start, $length), kind: $kind }, "Testing the lexing of string '{}'", $src ); }; } #[test] fn test_number_successes() { assert_token!("4", TokenKind::IntegerLiteral, 0, 1); assert_token!("4.123", TokenKind::FloatLiteral, 0, 5); assert_token!("-4", TokenKind::IntegerLiteral, 0, 2); assert_token!("9", TokenKind::IntegerLiteral, 0, 1); assert_token!("0", TokenKind::IntegerLiteral, 0, 1); assert_token!("-4.123", TokenKind::FloatLiteral, 0, 6); assert_token!("0.123", TokenKind::FloatLiteral, 0, 5); assert_token!("123e4", TokenKind::FloatLiteral, 0, 5); assert_token!("123E4", TokenKind::FloatLiteral, 0, 5); assert_token!("123e-4", TokenKind::FloatLiteral, 0, 6); assert_token!("123e+4", TokenKind::FloatLiteral, 0, 6); assert_token!("-1.123e4", TokenKind::FloatLiteral, 0, 8); assert_token!("-1.123E4", TokenKind::FloatLiteral, 0, 8); assert_token!("-1.123e-4", TokenKind::FloatLiteral, 0, 9); assert_token!("-1.123e+4", TokenKind::FloatLiteral, 0, 9); assert_token!("-1.123e4567", TokenKind::FloatLiteral, 0, 11); assert_token!("-0", TokenKind::IntegerLiteral, 0, 2); } #[test] fn test_number_failures() { assert_token!("00", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("01", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("-01", TokenKind::ErrorUnsupportedNumberLiteral, 0, 3); assert_token!("+1", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("01.23", TokenKind::ErrorUnsupportedNumberLiteral, 0, 5); assert_token!("1.", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("1e", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("1.e1", TokenKind::ErrorUnsupportedNumberLiteral, 0, 4); assert_token!("1.A", TokenKind::ErrorUnsupportedNumberLiteral, 0, 3); assert_token!("-A", TokenKind::ErrorUnsupportedNumberLiteral, 0, 2); assert_token!("1.0e", TokenKind::ErrorUnsupportedNumberLiteral, 0, 4); assert_token!("1.0eA", TokenKind::ErrorUnsupportedNumberLiteral, 0, 5); assert_token!("1.2e3e", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!("1.2e3.4", TokenKind::ErrorUnsupportedNumberLiteral, 0, 7); assert_token!("1.23.4", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!(".123", TokenKind::ErrorUnsupportedNumberLiteral, 0, 4); // check that we don't consume trailing valid items assert_token!("1.23.4{}", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!("1.23.4 {}", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!("1.23.4 []", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!("1.23.4 foo", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6); assert_token!( "1.23.4 $foo", TokenKind::ErrorUnsupportedNumberLiteral, 0, 6 ); } }
lex_string_literal_rest
siteverification-gen.go
// Package siteverification provides access to the Google Site Verification API. // // See https://developers.google.com/site-verification/ // // Usage example: // // import "google.golang.org/api/siteverification/v1" // ... // siteverificationService, err := siteverification.New(oauthHttpClient) package siteverification // import "google.golang.org/api/siteverification/v1" import ( "bytes" "encoding/json" "errors" "fmt" context "golang.org/x/net/context" ctxhttp "golang.org/x/net/context/ctxhttp" gensupport "google.golang.org/api/gensupport" googleapi "google.golang.org/api/googleapi" "io" "net/http" "net/url" "strconv" "strings" ) // Always reference these packages, just in case the auto-generated code // below doesn't. var _ = bytes.NewBuffer var _ = strconv.Itoa var _ = fmt.Sprintf var _ = json.NewDecoder var _ = io.Copy var _ = url.Parse var _ = gensupport.MarshalJSON var _ = googleapi.Version var _ = errors.New var _ = strings.Replace var _ = context.Canceled var _ = ctxhttp.Do const apiId = "siteVerification:v1" const apiName = "siteVerification" const apiVersion = "v1" const basePath = "https://www.googleapis.com/siteVerification/v1/" // OAuth2 scopes used by this API. const ( // Manage the list of sites and domains you control SiteverificationScope = "https://www.googleapis.com/auth/siteverification" // Manage your new site verifications with Google SiteverificationVerifyOnlyScope = "https://www.googleapis.com/auth/siteverification.verify_only" ) func New(client *http.Client) (*Service, error) { if client == nil { return nil, errors.New("client is nil") } s := &Service{client: client, BasePath: basePath} s.WebResource = NewWebResourceService(s) return s, nil } type Service struct { client *http.Client BasePath string // API endpoint base URL UserAgent string // optional additional User-Agent fragment WebResource *WebResourceService } func (s *Service) userAgent() string { if s.UserAgent == "" { return googleapi.UserAgent } return googleapi.UserAgent + " " + s.UserAgent } func NewWebResourceService(s *Service) *WebResourceService { rs := &WebResourceService{s: s} return rs } type WebResourceService struct { s *Service } type SiteVerificationWebResourceGettokenRequest struct { // Site: The site for which a verification token will be generated. Site *SiteVerificationWebResourceGettokenRequestSite `json:"site,omitempty"` // VerificationMethod: The verification method that will be used to // verify this site. For sites, 'FILE' or 'META' methods may be used. // For domains, only 'DNS' may be used. VerificationMethod string `json:"verificationMethod,omitempty"` // ForceSendFields is a list of field names (e.g. "Site") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceGettokenRequest) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceGettokenRequest raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // SiteVerificationWebResourceGettokenRequestSite: The site for which a // verification token will be generated. type SiteVerificationWebResourceGettokenRequestSite struct { // Identifier: The site identifier. If the type is set to SITE, the // identifier is a URL. If the type is set to INET_DOMAIN, the site // identifier is a domain name. Identifier string `json:"identifier,omitempty"` // Type: The type of resource to be verified. Can be SITE or INET_DOMAIN // (domain name). Type string `json:"type,omitempty"` // ForceSendFields is a list of field names (e.g. "Identifier") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceGettokenRequestSite) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceGettokenRequestSite raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type SiteVerificationWebResourceGettokenResponse struct { // Method: The verification method to use in conjunction with this // token. For FILE, the token should be placed in the top-level // directory of the site, stored inside a file of the same name. For // META, the token should be placed in the HEAD tag of the default page // that is loaded for the site. For DNS, the token should be placed in a // TXT record of the domain. Method string `json:"method,omitempty"` // Token: The verification token. The token must be placed appropriately // in order for verification to succeed. Token string `json:"token,omitempty"` // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` // ForceSendFields is a list of field names (e.g. "Method") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceGettokenResponse) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceGettokenResponse raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type SiteVerificationWebResourceListResponse struct { // Items: The list of sites that are owned by the authenticated user. Items []*SiteVerificationWebResourceResource `json:"items,omitempty"` // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` // ForceSendFields is a list of field names (e.g. "Items") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceListResponse) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceListResponse raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type SiteVerificationWebResourceResource struct { // Id: The string used to identify this site. This value should be used // in the "id" portion of the REST URL for the Get, Update, and Delete // operations. Id string `json:"id,omitempty"` // Owners: The email addresses of all verified owners. Owners []string `json:"owners,omitempty"` // Site: The address and type of a site that is verified or will be // verified. Site *SiteVerificationWebResourceResourceSite `json:"site,omitempty"` // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` // ForceSendFields is a list of field names (e.g. "Id") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceResource) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceResource raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // SiteVerificationWebResourceResourceSite: The address and type of a // site that is verified or will be verified. type SiteVerificationWebResourceResourceSite struct { // Identifier: The site identifier. If the type is set to SITE, the // identifier is a URL. If the type is set to INET_DOMAIN, the site // identifier is a domain name. Identifier string `json:"identifier,omitempty"` // Type: The site type. Can be SITE or INET_DOMAIN (domain name). Type string `json:"type,omitempty"` // ForceSendFields is a list of field names (e.g. "Identifier") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *SiteVerificationWebResourceResourceSite) MarshalJSON() ([]byte, error) { type noMethod SiteVerificationWebResourceResourceSite raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // method id "siteVerification.webResource.delete": type WebResourceDeleteCall struct { s *Service id string urlParams_ gensupport.URLParams ctx_ context.Context } // Delete: Relinquish ownership of a website or domain. func (r *WebResourceService) Delete(id string) *WebResourceDeleteCall { c := &WebResourceDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.id = id return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceDeleteCall) Fields(s ...googleapi.Field) *WebResourceDeleteCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceDeleteCall) Context(ctx context.Context) *WebResourceDeleteCall { c.ctx_ = ctx return c } func (c *WebResourceDeleteCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource/{id}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("DELETE", urls, body) googleapi.Expand(req.URL, map[string]string{ "id": c.id, }) req.Header.Set("User-Agent", c.s.userAgent()) if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.delete" call. func (c *WebResourceDeleteCall) Do(opts ...googleapi.CallOption) error { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if err != nil { return err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return err } return nil // { // "description": "Relinquish ownership of a website or domain.", // "httpMethod": "DELETE", // "id": "siteVerification.webResource.delete", // "parameterOrder": [ // "id" // ], // "parameters": { // "id": { // "description": "The id of a verified site or domain.", // "location": "path", // "required": true, // "type": "string" // } // }, // "path": "webResource/{id}", // "scopes": [ // "https://www.googleapis.com/auth/siteverification" // ] // } } // method id "siteVerification.webResource.get": type WebResourceGetCall struct { s *Service id string urlParams_ gensupport.URLParams ifNoneMatch_ string ctx_ context.Context } // Get: Get the most current data for a website or domain. func (r *WebResourceService) Get(id string) *WebResourceGetCall { c := &WebResourceGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.id = id return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceGetCall) Fields(s ...googleapi.Field) *WebResourceGetCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // IfNoneMatch sets the optional parameter which makes the operation // fail if the object's ETag matches the given value. This is useful for // getting updates only after the object has changed since the last // request. Use googleapi.IsNotModified to check whether the response // error from Do is the result of In-None-Match. func (c *WebResourceGetCall) IfNoneMatch(entityTag string) *WebResourceGetCall { c.ifNoneMatch_ = entityTag return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceGetCall) Context(ctx context.Context) *WebResourceGetCall { c.ctx_ = ctx return c } func (c *WebResourceGetCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource/{id}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("GET", urls, body) googleapi.Expand(req.URL, map[string]string{ "id": c.id, }) req.Header.Set("User-Agent", c.s.userAgent()) if c.ifNoneMatch_ != "" { req.Header.Set("If-None-Match", c.ifNoneMatch_) } if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.get" call. // Exactly one of *SiteVerificationWebResourceResource or error will be // non-nil. Any non-2xx status code is an error. Response headers are in // either *SiteVerificationWebResourceResource.ServerResponse.Header or // (if a response was returned at all) in // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check // whether the returned error was because http.StatusNotModified was // returned. func (c *WebResourceGetCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceResource, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceResource{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Get the most current data for a website or domain.", // "httpMethod": "GET", // "id": "siteVerification.webResource.get", // "parameterOrder": [ // "id" // ], // "parameters": { // "id": { // "description": "The id of a verified site or domain.", // "location": "path", // "required": true, // "type": "string" // } // }, // "path": "webResource/{id}", // "response": { // "$ref": "SiteVerificationWebResourceResource" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification" // ] // } } // method id "siteVerification.webResource.getToken": type WebResourceGetTokenCall struct { s *Service siteverificationwebresourcegettokenrequest *SiteVerificationWebResourceGettokenRequest urlParams_ gensupport.URLParams ctx_ context.Context } // GetToken: Get a verification token for placing on a website or // domain. func (r *WebResourceService) GetToken(siteverificationwebresourcegettokenrequest *SiteVerificationWebResourceGettokenRequest) *WebResourceGetTokenCall { c := &WebResourceGetTokenCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.siteverificationwebresourcegettokenrequest = siteverificationwebresourcegettokenrequest return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceGetTokenCall) Fields(s ...googleapi.Field) *WebResourceGetTokenCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceGetTokenCall) Context(ctx context.Context) *WebResourceGetTokenCall { c.ctx_ = ctx return c } func (c *WebResourceGetTokenCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil body, err := googleapi.WithoutDataWrapper.JSONReader(c.siteverificationwebresourcegettokenrequest) if err != nil { return nil, err } ctype := "application/json" c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "token") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("POST", urls, body) googleapi.SetOpaque(req.URL) req.Header.Set("Content-Type", ctype) req.Header.Set("User-Agent", c.s.userAgent())
return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.getToken" call. // Exactly one of *SiteVerificationWebResourceGettokenResponse or error // will be non-nil. Any non-2xx status code is an error. Response // headers are in either // *SiteVerificationWebResourceGettokenResponse.ServerResponse.Header or // (if a response was returned at all) in // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check // whether the returned error was because http.StatusNotModified was // returned. func (c *WebResourceGetTokenCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceGettokenResponse, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceGettokenResponse{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Get a verification token for placing on a website or domain.", // "httpMethod": "POST", // "id": "siteVerification.webResource.getToken", // "path": "token", // "request": { // "$ref": "SiteVerificationWebResourceGettokenRequest" // }, // "response": { // "$ref": "SiteVerificationWebResourceGettokenResponse" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification", // "https://www.googleapis.com/auth/siteverification.verify_only" // ] // } } // method id "siteVerification.webResource.insert": type WebResourceInsertCall struct { s *Service siteverificationwebresourceresource *SiteVerificationWebResourceResource urlParams_ gensupport.URLParams ctx_ context.Context } // Insert: Attempt verification of a website or domain. func (r *WebResourceService) Insert(verificationMethod string, siteverificationwebresourceresource *SiteVerificationWebResourceResource) *WebResourceInsertCall { c := &WebResourceInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.urlParams_.Set("verificationMethod", verificationMethod) c.siteverificationwebresourceresource = siteverificationwebresourceresource return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceInsertCall) Fields(s ...googleapi.Field) *WebResourceInsertCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceInsertCall) Context(ctx context.Context) *WebResourceInsertCall { c.ctx_ = ctx return c } func (c *WebResourceInsertCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil body, err := googleapi.WithoutDataWrapper.JSONReader(c.siteverificationwebresourceresource) if err != nil { return nil, err } ctype := "application/json" c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("POST", urls, body) googleapi.SetOpaque(req.URL) req.Header.Set("Content-Type", ctype) req.Header.Set("User-Agent", c.s.userAgent()) if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.insert" call. // Exactly one of *SiteVerificationWebResourceResource or error will be // non-nil. Any non-2xx status code is an error. Response headers are in // either *SiteVerificationWebResourceResource.ServerResponse.Header or // (if a response was returned at all) in // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check // whether the returned error was because http.StatusNotModified was // returned. func (c *WebResourceInsertCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceResource, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceResource{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Attempt verification of a website or domain.", // "httpMethod": "POST", // "id": "siteVerification.webResource.insert", // "parameterOrder": [ // "verificationMethod" // ], // "parameters": { // "verificationMethod": { // "description": "The method to use for verifying a site or domain.", // "location": "query", // "required": true, // "type": "string" // } // }, // "path": "webResource", // "request": { // "$ref": "SiteVerificationWebResourceResource" // }, // "response": { // "$ref": "SiteVerificationWebResourceResource" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification", // "https://www.googleapis.com/auth/siteverification.verify_only" // ] // } } // method id "siteVerification.webResource.list": type WebResourceListCall struct { s *Service urlParams_ gensupport.URLParams ifNoneMatch_ string ctx_ context.Context } // List: Get the list of your verified websites and domains. func (r *WebResourceService) List() *WebResourceListCall { c := &WebResourceListCall{s: r.s, urlParams_: make(gensupport.URLParams)} return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceListCall) Fields(s ...googleapi.Field) *WebResourceListCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // IfNoneMatch sets the optional parameter which makes the operation // fail if the object's ETag matches the given value. This is useful for // getting updates only after the object has changed since the last // request. Use googleapi.IsNotModified to check whether the response // error from Do is the result of In-None-Match. func (c *WebResourceListCall) IfNoneMatch(entityTag string) *WebResourceListCall { c.ifNoneMatch_ = entityTag return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceListCall) Context(ctx context.Context) *WebResourceListCall { c.ctx_ = ctx return c } func (c *WebResourceListCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("GET", urls, body) googleapi.SetOpaque(req.URL) req.Header.Set("User-Agent", c.s.userAgent()) if c.ifNoneMatch_ != "" { req.Header.Set("If-None-Match", c.ifNoneMatch_) } if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.list" call. // Exactly one of *SiteVerificationWebResourceListResponse or error will // be non-nil. Any non-2xx status code is an error. Response headers are // in either // *SiteVerificationWebResourceListResponse.ServerResponse.Header or (if // a response was returned at all) in error.(*googleapi.Error).Header. // Use googleapi.IsNotModified to check whether the returned error was // because http.StatusNotModified was returned. func (c *WebResourceListCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceListResponse, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceListResponse{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Get the list of your verified websites and domains.", // "httpMethod": "GET", // "id": "siteVerification.webResource.list", // "path": "webResource", // "response": { // "$ref": "SiteVerificationWebResourceListResponse" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification" // ] // } } // method id "siteVerification.webResource.patch": type WebResourcePatchCall struct { s *Service id string siteverificationwebresourceresource *SiteVerificationWebResourceResource urlParams_ gensupport.URLParams ctx_ context.Context } // Patch: Modify the list of owners for your website or domain. This // method supports patch semantics. func (r *WebResourceService) Patch(id string, siteverificationwebresourceresource *SiteVerificationWebResourceResource) *WebResourcePatchCall { c := &WebResourcePatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.id = id c.siteverificationwebresourceresource = siteverificationwebresourceresource return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourcePatchCall) Fields(s ...googleapi.Field) *WebResourcePatchCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourcePatchCall) Context(ctx context.Context) *WebResourcePatchCall { c.ctx_ = ctx return c } func (c *WebResourcePatchCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil body, err := googleapi.WithoutDataWrapper.JSONReader(c.siteverificationwebresourceresource) if err != nil { return nil, err } ctype := "application/json" c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource/{id}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("PATCH", urls, body) googleapi.Expand(req.URL, map[string]string{ "id": c.id, }) req.Header.Set("Content-Type", ctype) req.Header.Set("User-Agent", c.s.userAgent()) if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.patch" call. // Exactly one of *SiteVerificationWebResourceResource or error will be // non-nil. Any non-2xx status code is an error. Response headers are in // either *SiteVerificationWebResourceResource.ServerResponse.Header or // (if a response was returned at all) in // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check // whether the returned error was because http.StatusNotModified was // returned. func (c *WebResourcePatchCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceResource, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceResource{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Modify the list of owners for your website or domain. This method supports patch semantics.", // "httpMethod": "PATCH", // "id": "siteVerification.webResource.patch", // "parameterOrder": [ // "id" // ], // "parameters": { // "id": { // "description": "The id of a verified site or domain.", // "location": "path", // "required": true, // "type": "string" // } // }, // "path": "webResource/{id}", // "request": { // "$ref": "SiteVerificationWebResourceResource" // }, // "response": { // "$ref": "SiteVerificationWebResourceResource" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification" // ] // } } // method id "siteVerification.webResource.update": type WebResourceUpdateCall struct { s *Service id string siteverificationwebresourceresource *SiteVerificationWebResourceResource urlParams_ gensupport.URLParams ctx_ context.Context } // Update: Modify the list of owners for your website or domain. func (r *WebResourceService) Update(id string, siteverificationwebresourceresource *SiteVerificationWebResourceResource) *WebResourceUpdateCall { c := &WebResourceUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.id = id c.siteverificationwebresourceresource = siteverificationwebresourceresource return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *WebResourceUpdateCall) Fields(s ...googleapi.Field) *WebResourceUpdateCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *WebResourceUpdateCall) Context(ctx context.Context) *WebResourceUpdateCall { c.ctx_ = ctx return c } func (c *WebResourceUpdateCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil body, err := googleapi.WithoutDataWrapper.JSONReader(c.siteverificationwebresourceresource) if err != nil { return nil, err } ctype := "application/json" c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "webResource/{id}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("PUT", urls, body) googleapi.Expand(req.URL, map[string]string{ "id": c.id, }) req.Header.Set("Content-Type", ctype) req.Header.Set("User-Agent", c.s.userAgent()) if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "siteVerification.webResource.update" call. // Exactly one of *SiteVerificationWebResourceResource or error will be // non-nil. Any non-2xx status code is an error. Response headers are in // either *SiteVerificationWebResourceResource.ServerResponse.Header or // (if a response was returned at all) in // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check // whether the returned error was because http.StatusNotModified was // returned. func (c *WebResourceUpdateCall) Do(opts ...googleapi.CallOption) (*SiteVerificationWebResourceResource, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &SiteVerificationWebResourceResource{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Modify the list of owners for your website or domain.", // "httpMethod": "PUT", // "id": "siteVerification.webResource.update", // "parameterOrder": [ // "id" // ], // "parameters": { // "id": { // "description": "The id of a verified site or domain.", // "location": "path", // "required": true, // "type": "string" // } // }, // "path": "webResource/{id}", // "request": { // "$ref": "SiteVerificationWebResourceResource" // }, // "response": { // "$ref": "SiteVerificationWebResourceResource" // }, // "scopes": [ // "https://www.googleapis.com/auth/siteverification" // ] // } }
if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) }
orm.go
// Code generated by mockery v2.8.0. DO NOT EDIT. package mocks import ( context "context" feeds "github.com/smartcontractkit/chainlink/core/services/feeds" mock "github.com/stretchr/testify/mock" ) // ORM is an autogenerated mock type for the ORM type type ORM struct { mock.Mock } // CountManagers provides a mock function with given fields: func (_m *ORM) CountManagers() (int64, error) { ret := _m.Called() var r0 int64 if rf, ok := ret.Get(0).(func() int64); ok { r0 = rf() } else { r0 = ret.Get(0).(int64) } var r1 error if rf, ok := ret.Get(1).(func() error); ok { r1 = rf() } else { r1 = ret.Error(1) } return r0, r1 } // CreateManager provides a mock function with given fields: ctx, ms func (_m *ORM) CreateManager(ctx context.Context, ms *feeds.FeedsManager) (int32, error) { ret := _m.Called(ctx, ms) var r0 int32 if rf, ok := ret.Get(0).(func(context.Context, *feeds.FeedsManager) int32); ok { r0 = rf(ctx, ms) } else { r0 = ret.Get(0).(int32) } var r1 error if rf, ok := ret.Get(1).(func(context.Context, *feeds.FeedsManager) error); ok { r1 = rf(ctx, ms) } else { r1 = ret.Error(1) } return r0, r1 } // GetManager provides a mock function with given fields: ctx, id func (_m *ORM) GetManager(ctx context.Context, id int32) (*feeds.FeedsManager, error) { ret := _m.Called(ctx, id) var r0 *feeds.FeedsManager if rf, ok := ret.Get(0).(func(context.Context, int32) *feeds.FeedsManager); ok { r0 = rf(ctx, id) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*feeds.FeedsManager) } } var r1 error if rf, ok := ret.Get(1).(func(context.Context, int32) error); ok { r1 = rf(ctx, id) } else { r1 = ret.Error(1) } return r0, r1 } // ListManagers provides a mock function with given fields: ctx func (_m *ORM) ListManagers(ctx context.Context) ([]feeds.FeedsManager, error) { ret := _m.Called(ctx) var r0 []feeds.FeedsManager if rf, ok := ret.Get(0).(func(context.Context) []feeds.FeedsManager); ok { r0 = rf(ctx) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]feeds.FeedsManager) } }
} else { r1 = ret.Error(1) } return r0, r1 }
var r1 error if rf, ok := ret.Get(1).(func(context.Context) error); ok { r1 = rf(ctx)
cmdprompt.rs
// (C) 2020 Srimanta Barua <[email protected]> use std::cell::RefCell; use std::rc::Rc; use euclid::{point2, size2, Rect, Size2D}; use unicode_segmentation::UnicodeSegmentation; use crate::buffer::CursorStyle; use crate::common::{PixelSize, DPI}; use crate::config::Config; use crate::input::{Action, Motion, MotionOrObj}; use crate::painter::Painter; use crate::style::TextStyle; use crate::text::{RopeOrStr, ShapedText, TextAlignment, TextShaper}; use crate::theme::Theme; const TAB_WIDTH: usize = 8; pub(crate) struct CmdPrompt { command: String, pub(crate) rect: Rect<u32, PixelSize>, // Text shaping dpi: Size2D<u32, DPI>, text_shaper: Rc<RefCell<TextShaper>>, // Shaped text shaped: ShapedText, ascender: i32, descender: i32, // Misc. config: Rc<Config>, theme: Rc<Theme>, prompt_len: usize, cursor_bidx: usize, cursor_gidx: usize, } impl CmdPrompt { pub(crate) fn new( config: Rc<Config>, dpi: Size2D<u32, DPI>, text_shaper: Rc<RefCell<TextShaper>>, win_rect: Rect<u32, PixelSize>, theme: Rc<Theme>, ) -> CmdPrompt { let (ascender, descender, shaped) = { let shaper = &mut *text_shaper.borrow_mut(); let raster = shaper .get_raster(config.prompt_face, TextStyle::default()) .unwrap(); let metrics = raster.get_metrics(config.prompt_font_size, dpi); let shaped = shaper.shape_line( "".into(), dpi, TAB_WIDTH, &[(0, config.prompt_face)], &[(0, TextStyle::default())], &[(0, config.prompt_font_size)], &[(0, theme.prompt.foreground)], &[(0, None)], &[(0, TextAlignment::Left)], ); (metrics.ascender, metrics.descender, shaped) }; let height = (ascender - descender) as u32; let rheight = height + config.prompt_padding_vertical * 2; assert!(win_rect.size.height > rheight); let rect = Rect::new( point2( win_rect.origin.x, win_rect.origin.y + win_rect.size.height - rheight, ), size2(win_rect.size.width, rheight), ); CmdPrompt { command: "".to_owned(), rect, config, dpi, text_shaper, shaped, ascender, descender, theme, prompt_len: 0, cursor_bidx: 0, cursor_gidx: 0, } } pub(crate) fn draw(&self, painter: &mut Painter) { let shaper = &mut *self.text_shaper.borrow_mut(); let mut painter = painter.widget_ctx(self.rect.cast(), self.theme.prompt.background, false); let pos = point2( self.config.prompt_padding_horizontal as i32, self.config.prompt_padding_vertical as i32 + self.ascender, ); let cursor = if self.command.len() > 0 { Some(( self.cursor_gidx, self.theme.prompt.cursor, CursorStyle::Line, )) } else { None }; painter.draw_shaped_text( shaper, pos, &self.shaped, cursor, self.rect.size.width - self.config.prompt_padding_horizontal, (self.ascender - self.descender) as u32, false, ); } pub(crate) fn resize(&mut self, win_rect: Rect<u32, PixelSize>) -> Rect<u32, PixelSize> { let height = (self.ascender - self.descender) as u32; let rheight = height + self.config.prompt_padding_vertical * 2; assert!(win_rect.size.height > rheight); self.rect.origin.x = win_rect.origin.x; self.rect.origin.y = win_rect.origin.y + win_rect.size.height - rheight; self.rect.size.width = win_rect.size.width; Rect::new( win_rect.origin, size2(win_rect.size.width, win_rect.size.height - rheight), ) } pub(crate) fn set_prompt(&mut self, s: &str) { self.command.clear(); self.command.push_str(s); self.prompt_len = s.len(); let (_, gidx) = bidx_gidx_from_bidx(&self.command, self.prompt_len); self.cursor_bidx = self.prompt_len; self.cursor_gidx = gidx; self.reshape(); } pub(crate) fn clear(&mut self)
pub(crate) fn get_command(&mut self) -> String { self.command[self.prompt_len..].to_owned() } pub(crate) fn handle_action(&mut self, action: &Action) { match action { Action::Move(m) => match m { MotionOrObj::Motion(Motion::Left(0)) | MotionOrObj::Motion(Motion::Right(0)) => { return } MotionOrObj::Motion(Motion::Left(mut n)) => { let mut start = self.cursor_bidx; let mut cis = self.command[self.prompt_len..self.cursor_bidx].char_indices(); while let Some((i, _)) = cis.next_back() { start = self.prompt_len + i; n -= 1; if n == 0 { break; } } if start == self.cursor_bidx { return; } let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, start); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::Right(mut n)) => { n += 1; let mut end = self.cursor_bidx; for (i, _) in self.command[self.cursor_bidx..].char_indices() { end = self.cursor_bidx + i; n -= 1; if n == 0 { break; } } if n > 0 { end = self.command.len(); } if end == self.cursor_bidx { return; } let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, end); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::LineStart) => { let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.prompt_len); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::LineEnd) => { let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.command.len()); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } _ => {} }, Action::Delete(m) => match m { MotionOrObj::Motion(Motion::Left(0)) | MotionOrObj::Motion(Motion::Right(0)) => { return } MotionOrObj::Motion(Motion::Left(mut n)) => { let mut start = self.cursor_bidx; let mut cis = self.command[self.prompt_len..self.cursor_bidx].char_indices(); while let Some((i, _)) = cis.next_back() { start = self.prompt_len + i; n -= 1; if n == 0 { break; } } if start == self.cursor_bidx { return; } self.command.replace_range(start..self.cursor_bidx, ""); let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, start); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::Right(mut n)) => { n += 1; let mut end = self.cursor_bidx; for (i, _) in self.command[self.cursor_bidx..].char_indices() { end = self.cursor_bidx + i; n -= 1; if n == 0 { break; } } if n > 0 { end = self.command.len(); } if end == self.cursor_bidx { return; } self.command.replace_range(self.cursor_bidx..end, ""); let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.cursor_bidx); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::LineStart) => { self.command .replace_range(self.prompt_len..self.cursor_bidx, ""); let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.prompt_len); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } MotionOrObj::Motion(Motion::LineEnd) => { self.command.replace_range(self.cursor_bidx.., ""); let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.cursor_bidx); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } _ => {} }, Action::InsertChar(c) => { self.command.insert(self.cursor_bidx, *c); self.cursor_bidx += c.len_utf8(); let (bidx, gidx) = bidx_gidx_from_bidx(&self.command, self.cursor_bidx); self.cursor_bidx = bidx; self.cursor_gidx = gidx; } _ => {} } self.reshape(); } fn reshape(&mut self) { let lc = self.command.chars().count(); let shaper = &mut *self.text_shaper.borrow_mut(); self.shaped = shaper.shape_line( RopeOrStr::from(self.command.as_ref()), self.dpi, TAB_WIDTH, &[(lc, self.config.prompt_face)], &[(lc, TextStyle::default())], &[(lc, self.config.prompt_font_size)], &[(lc, self.theme.prompt.foreground)], &[(lc, None)], &[(lc, TextAlignment::Left)], ); } } fn bidx_gidx_from_bidx(s: &str, bidx: usize) -> (usize, usize) { let (mut gidx, mut blen) = (0, 0); for g in s.graphemes(true) { let len = g.len(); if len + blen > bidx { return (blen, gidx); } blen += len; if g == "\t" { gidx = (gidx / TAB_WIDTH) * TAB_WIDTH + TAB_WIDTH; } else { gidx += 1; } } (blen, gidx) }
{ self.command.clear(); self.prompt_len = 0; self.cursor_bidx = 0; self.cursor_gidx = 0; self.reshape(); }
visualizer.integration.ts
// Copyright IBM Corp. 2020. All Rights Reserved. // Node module: @loopback/context-explorer // This file is licensed under the MIT License. // License text available at https://opensource.org/licenses/MIT import {Context} from '@loopback/core'; import {expect} from '@loopback/testlab'; import {ContextGraph} from '../..'; import {renderGraph} from '../../visualizer'; describe('Visualizer', () => { let app: Context; let server: Context; beforeEach(givenContexts);
it('creates a dot graph with bindings', async function (this: Mocha.Context) { if ((process.platform as string) === 'os390') return this.skip(); server.bind('port').to(3000); app.bind('now').toDynamicValue(() => new Date()); const json = server.inspect(); const graph = new ContextGraph(json); const dot = graph.render(); const svg = await renderGraph(dot, {engine: 'fdp', format: 'svg'}); expect(svg).to.match(/^<\?xml/); expect(svg).to.match(/<svg /); }); function givenContexts() { app = new Context('app'); server = new Context(app, 'server'); } });
solve.py
######## # PART 1 def dragon_step(a): """ For example, after a single step of this process, 1 becomes 100. 0 becomes 001. 11111 becomes 11111000000. 111100001010 becomes 1111000010100101011110000 """ b = [0 if x==1 else 1 for x in a] b.reverse() return a + [0] + b def checksum(input): """ Consider each pair: 11, 00, 10, 11, 01, 00. These are same, same, different, same, different, same, producing 110101. The resulting string has length 6, which is even, so we repeat the process. The pairs are 11 (same), 01 (different), 01 (different). This produces the checksum 100, which has an odd length, so we stop. """ calc = [1 if a == b else 0 for a, b in zip(input[::2], input[1::2])] if len(calc) % 2 == 0: calc = checksum(calc) return calc def
(disc, length): while len(disc) < length: disc = dragon_step(disc) return disc[:length] assert dragon_step([1]) == [1, 0, 0] assert dragon_step([0]) == [0, 0, 1] assert dragon_step([1,1,1,1,1]) == [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] assert dragon_step([1,1,1,1,0,0,0,0,1,0,1,0]) == [1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0] assert checksum([1,1,0,0,1,0,1,1,0,1,0,0]) == [1, 0, 0] example = generate_disc([1,0,0,0,0], 20) assert checksum(example) == [0,1,1,0,0] p1 = generate_disc([1,0,0,1,1,1,1,1,0,1,1,0,1,1,0,0,1], 272) answer = "".join(map(str, checksum(p1))) print("Part 1 =", answer) assert answer == "10111110010110110" # check with accepted answer ######## # PART 2 p2 = generate_disc([1,0,0,1,1,1,1,1,0,1,1,0,1,1,0,0,1], 35651584) answer = "".join(map(str, checksum(p2))) print("Part 2 =", answer) assert answer == "01101100001100100" # check with accepted answer
generate_disc
DevModeService.js
service: "palm://org.webosports.service.devmode/" });
enyo.kind({ name: "DevModeService", kind: "enyo.PalmService",
count_facets.py
import json
combine = jydoop.sumreducer def map(key, value, context): try: payload = json.loads(value) except: context.write("Bogus\tBogus\tBogus\tBogus", 1) return output = [] try: info = payload['geckoAppInfo'] if type(info) == dict: output.append(info['name']) output.append(info['os']) output.append(info['updateChannel']) output.append(info['version']) except KeyError: pass if len(output) == 4: outkey = "\t".join(output) context.write(outkey, 1) reduce = jydoop.sumreducer
import jydoop import healthreportutils setupjob = healthreportutils.setupjob
game-creation-service.ts
import {Injectable} from "@angular/core"; import {Http} from "@angular/http"; import "rxjs/add/operator/map"; import {Data, VersionStored} from "./start-up-data/load-data"; import {Storage} from "@ionic/storage"; @Injectable() export class GameCreationService { constructor( private http: Http, private storage: Storage, ) { console.log('Hello GameCreationService Provider'); } loadData(versionStorageKey: string, levelStorageKey: string): Promise<any> { let env = this; let version: Promise<VersionStored> = env.http.get("assets/levels.json") .map(res => { return { key: versionStorageKey, value: res.json().version } }) .toPromise(); return version.then((latestVersion) => { return env.checkVersionStored(latestVersion) .then((versionIsDifferent) => { if (versionIsDifferent) { return env.storeDataFromJson("assets/levels.json", levelStorageKey); } else { return Promise.resolve(); } }) }) } checkVersionStored(version: VersionStored): Promise<boolean> { let env = this; return env.storage.get(version.key).then((versionValue) => { let versionIsDifferent = versionValue != version.value; let promise = Promise.resolve(versionIsDifferent); if (versionIsDifferent) { promise = env.storage.set(version.key, version.value)
console.log("Database updated to version " + version.value); return versionIsDifferent; }) } else { console.log("Database up to date already (v." + versionValue + ")"); } return promise; }); } storeDataFromJson(url: string, levelStorageKey: string): Promise<any> { let env = this; console.log("Setting up database..."); return env.http.get(url) .map(res => res.json().levels) .map((levelsData) => { let data = new Data(levelStorageKey, levelsData); return data.storeData(env.storage); }) .toPromise(); } }
.then(() => {
users_test.go
package models import ( "fmt" "testing" "chirp.com/config" "chirp.com/testdata" ) func
(t *testing.T) { cfg := config.TestConfig() dbCfg := cfg.Database testdata.ResetDB(cfg) services, err := NewServices( WithGorm(dbCfg.Dialect(), dbCfg.ConnectionInfo()), WithLogMode(!cfg.IsProd()), // WithUser(cfg.Pepper, cfg.HMACKey), ) if err != nil { t.Error(err) } defer services.Close() userDB := &userGorm{services.db} user, err := userDB.ByEmail("[email protected]") if err != nil { t.Error(err) } fmt.Println(user) }
TestUserDB
integration_test.go
/* Copyright 2019 The Knative Authors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package resources import ( "testing" "knative.dev/eventing-contrib/camel/source/pkg/apis/sources/v1alpha1" camelv1alpha1 "github.com/apache/camel-k/pkg/apis/camel/v1alpha1" "github.com/google/go-cmp/cmp" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) func TestMakeDeployment_sink(t *testing.T) { got, err := MakeIntegration(&CamelArguments{ Name: "test-name", Namespace: "test-namespace", Source: v1alpha1.CamelSourceOriginSpec{ DeprecatedComponent: &v1alpha1.CamelSourceOriginComponentSpec{ URI: "timer:tick", Properties: map[string]string{ "k": "v", "k2": "v2", }, ServiceAccountName: "test-service-account", Context: "test-context", }, }, Sink: "http://test-sink", }) if err != nil { t.Error(err) } want := &camelv1alpha1.Integration{ TypeMeta: metav1.TypeMeta{ APIVersion: "camel.apache.org/v1alpha1", Kind: "Integration", }, ObjectMeta: metav1.ObjectMeta{ GenerateName: "test-name-", Namespace: "test-namespace", }, Spec: camelv1alpha1.IntegrationSpec{ ServiceAccountName: "test-service-account", Kit: "test-context", Sources: []camelv1alpha1.SourceSpec{ { DataSpec: camelv1alpha1.DataSpec{ Name: "source.yaml", Content: "- from:\n steps:\n - to:\n uri: knative://endpoint/sink\n uri: timer:tick\n", }, }, }, Configuration: []camelv1alpha1.ConfigurationSpec{ { Type: "property", Value: "k=v", }, { Type: "property", Value: "k2=v2", }, }, Traits: map[string]camelv1alpha1.TraitSpec{ "knative": { Configuration: map[string]string{ "configuration": `{"services":[{"type":"endpoint","protocol":"http","name":"sink","host":"test-sink","port":80,"metadata":{"service.path":"/"}}]}`, }, }, }, }, } if diff := cmp.Diff(want, got); diff != "" {
t.Errorf("unexpected integration (-want, +got) = %v", diff) } }
philpapers.js
// this api is the work of the PhilPapers team (http://philpapers.org). all rights reserved. var xpapers_embed_buffer = ''; xpapers_embed_buffer += "<ol class='xpapers_entryList'> <li id='eSANADO-9' class='xpapers_entry'><span class=\"xpapers_citation\"><a class='xpapers_title' href=\"http://philpapers.org/rec/SANADO-9\" target=\"_blank\">A Defense of Modest Foundationalism.</a><span class='xpapers_pubInfo'></span></span><div class=\"xpapers_extras\"></div></li> "; xpapers_embed_buffer += "<li id='eSANERI-2' class='xpapers_entry'><span class=\"xpapers_citation\"><a class='xpapers_title' href=\"http://philpapers.org/rec/SANERI-2\" target=\"_blank\">Empathy&#39;s Role in Understanding the World.</a><span class='xpapers_pubInfo'></span></span><div class=\"xpapers_extras\"></div></li> "; xpapers_embed_buffer += "<li id='eSANJTO' class='xpapers_entry'><span class=\"xpapers_citation\"><a class='xpapers_title' href=\"http://philpapers.org/rec/SANJTO\" target=\"_blank\">Jewish Teachings of Mankind and God in the Book of Genesis 1-3.</a><span class='xpapers_pubInfo'></span></span><div class=\"xpapers_extras\"></div></li> "; xpapers_embed_buffer += "<li id='eSANOTA-4' class='xpapers_entry'><span class=\"xpapers_citation\"><a class='xpapers_title' href=\"https://philpapers.org/rec/SANOTA-4\">On the Absurdity of Theistic Evolution.</a><span class='xpapers_pubInfo'></span></span><div class=\"xpapers_extras\"></div></li> "; xpapers_embed_buffer += "<li id='SANNAT-3' class='xpapers_entry'><span class=\"xpapers_citation\"><a class='xpapers_title' href=\"https://philpapers.org/rec/SANNAT-3\">Neoliberalism and the Emerging Precariat.</a><span class='xpapers_pubInfo'></span></span><div class=\"xpapers_extras\"></div></li>"; function
() { if (arguments.callee.done) return; arguments.callee.done = true; var el = document.getElementById('xpapers_gadget'); if (el) { el.innerHTML = xpapers_embed_buffer + "<div style='font-size:smaller;padding-top:12.5px;padding-right:25px;text-align:center'>powered by <a href='http://philpapers.org'>PhilPapers</a>&nbsp;&nbsp;|&nbsp;&nbsp;<a href='http://philpapers.org/profile/207902/myworks.pl?refresh=1'>Refresh</a>"; } } if (document.addEventListener) { document.addEventListener('DOMContentLoaded', xpapers_embed_init, false); } (function() { /*@*/ try { document.body.doScroll('up'); return xpapers_embed_init(); } catch(e) {} /* (false) @*/ if (/loaded|complete/.test(document.readyState)) return xpapers_embed_init(); /* @*/ if (!xpapers_embed_init.done) setTimeout(arguments.callee, 30); })(); if (window.addEventListener) { window.addEventListener('load', xpapers_embed_init, false); } else if (window.attachEvent) { window.attachEvent('onload', xpapers_embed_init); }
xpapers_embed_init
util_style.py
# -*- coding: utf-8 -*- """ """ class StyleUtil(object): """ """ @staticmethod def
(column, vp=None): """ :param column: :param vp: """ pass
create_gradient
log.go
/* Copyright 2019 The Kubernetes Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package framework import ( "bytes" "fmt" "regexp" "runtime/debug" "time" "github.com/onsi/ginkgo" ) func nowStamp() string { return time.Now().Format(time.StampMilli) } func log(level string, format string, args ...interface{}) { fmt.Fprintf(ginkgo.GinkgoWriter, nowStamp()+": "+level+": "+format+"\n", args...) } // Logf logs the info. func Logf(format string, args ...interface{}) { log("INFO", format, args...) } // Failf logs the fail info, including a stack trace starts at 2 levels above its caller // (for example, for call chain f -> g -> Failf("foo", ...) error would be logged for "f"). func Failf(format string, args ...interface{}) { msg := fmt.Sprintf(format, args...) skip := 2 log("FAIL", "%s\n\nFull Stack Trace\n%s", msg, PrunedStack(skip)) ginkgoFail(nowStamp()+": "+msg, skip) } // Fail is a replacement for ginkgo.Fail which logs the problem as it occurs // together with a stack trace and then calls ginkgowrapper.Fail. func Fail(msg string, callerSkip ...int) { skip := 1 if len(callerSkip) > 0 { skip += callerSkip[0] } log("FAIL", "%s\n\nFull Stack Trace\n%s", msg, PrunedStack(skip)) ginkgoFail(nowStamp()+": "+msg, skip) } var codeFilterRE = regexp.MustCompile(`/github.com/onsi/ginkgo/`) // PrunedStack is a wrapper around debug.Stack() that removes information // about the current goroutine and optionally skips some of the initial stack entries. // With skip == 0, the returned stack will start with the caller of PruneStack. // From the remaining entries it automatically filters out useless ones like // entries coming from Ginkgo. // // This is a modified copy of PruneStack in https://github.com/onsi/ginkgo/blob/f90f37d87fa6b1dd9625e2b1e83c23ffae3de228/internal/codelocation/code_location.go#L25: // - simplified API and thus renamed (calls debug.Stack() instead of taking a parameter) // - source code filtering updated to be specific to Kubernetes // - optimized to use bytes and in-place slice filtering from // https://github.com/golang/go/wiki/SliceTricks#filter-in-place func PrunedStack(skip int) []byte { fullStackTrace := debug.Stack() stack := bytes.Split(fullStackTrace, []byte("\n")) // Ensure that the even entries are the method names and the // the odd entries the source code information. if len(stack) > 0 && bytes.HasPrefix(stack[0], []byte("goroutine ")) { // Ignore "goroutine 29 [running]:" line. stack = stack[1:] } // The "+2" is for skipping over: // - runtime/debug.Stack() // - PrunedStack() skip += 2 if len(stack) > 2*skip
n := 0 for i := 0; i < len(stack)/2; i++ { // We filter out based on the source code file name. if !codeFilterRE.Match([]byte(stack[i*2+1])) { stack[n] = stack[i*2] stack[n+1] = stack[i*2+1] n += 2 } } stack = stack[:n] return bytes.Join(stack, []byte("\n")) }
{ stack = stack[2*skip:] }
test_sentence.py
# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for positioning sentences. """ from __future__ import absolute_import, division import itertools from twisted.positioning import _sentence from twisted.trial.unittest import TestCase sentinelValueOne = "someStringValue" sentinelValueTwo = "someOtherStringValue" class DummyProtocol(object): """ A simple, fake protocol. """ @staticmethod def getSentenceAttributes(): return ["type", sentinelValueOne, sentinelValueTwo] class DummySentence(_sentence._BaseSentence):
""" A sentence for L{DummyProtocol}. """ ALLOWED_ATTRIBUTES = DummyProtocol.getSentenceAttributes() class MixinProtocol(_sentence._PositioningSentenceProducerMixin): """ A simple, fake protocol that declaratively tells you the sentences it produces using L{base.PositioningSentenceProducerMixin}. """ _SENTENCE_CONTENTS = { None: [ sentinelValueOne, sentinelValueTwo, None # See MixinTests.test_noNoneInSentenceAttributes ], } class MixinSentence(_sentence._BaseSentence): """ A sentence for L{MixinProtocol}. """ ALLOWED_ATTRIBUTES = MixinProtocol.getSentenceAttributes() class SentenceTestsMixin(object): """ Tests for positioning protocols and their respective sentences. """ def test_attributeAccess(self): """ A sentence attribute gets the correct value, and accessing an unset attribute (which is specified as being a valid sentence attribute) gets L{None}. """ thisSentinel = object() sentence = self.sentenceClass({sentinelValueOne: thisSentinel}) self.assertEqual(getattr(sentence, sentinelValueOne), thisSentinel) self.assertIsNone(getattr(sentence, sentinelValueTwo)) def test_raiseOnMissingAttributeAccess(self): """ Accessing a nonexistent attribute raises C{AttributeError}. """ sentence = self.sentenceClass({}) self.assertRaises(AttributeError, getattr, sentence, "BOGUS") def test_raiseOnBadAttributeAccess(self): """ Accessing bogus attributes raises C{AttributeError}, *even* when that attribute actually is in the sentence data. """ sentence = self.sentenceClass({"BOGUS": None}) self.assertRaises(AttributeError, getattr, sentence, "BOGUS") sentenceType = "tummies" reprTemplate = "<%s (%s) {%s}>" def _expectedRepr(self, sentenceType="unknown type", dataRepr=""): """ Builds the expected repr for a sentence. @param sentenceType: The name of the sentence type (e.g "GPGGA"). @type sentenceType: C{str} @param dataRepr: The repr of the data in the sentence. @type dataRepr: C{str} @return: The expected repr of the sentence. @rtype: C{str} """ clsName = self.sentenceClass.__name__ return self.reprTemplate % (clsName, sentenceType, dataRepr) def test_unknownTypeRepr(self): """ Test the repr of an empty sentence of unknown type. """ sentence = self.sentenceClass({}) expectedRepr = self._expectedRepr() self.assertEqual(repr(sentence), expectedRepr) def test_knownTypeRepr(self): """ Test the repr of an empty sentence of known type. """ sentence = self.sentenceClass({"type": self.sentenceType}) expectedRepr = self._expectedRepr(self.sentenceType) self.assertEqual(repr(sentence), expectedRepr) class MixinTests(TestCase, SentenceTestsMixin): """ Tests for protocols deriving from L{base.PositioningSentenceProducerMixin} and their sentences. """ def setUp(self): self.protocol = MixinProtocol() self.sentenceClass = MixinSentence def test_noNoneInSentenceAttributes(self): """ L{None} does not appear in the sentence attributes of the protocol, even though it's in the specification. This is because L{None} is a placeholder for parts of the sentence you don't really need or want, but there are some bits later on in the sentence that you do want. The alternative would be to have to specify things like "_UNUSED0", "_UNUSED1"... which would end up cluttering the sentence data and eventually adapter state. """ sentenceAttributes = self.protocol.getSentenceAttributes() self.assertNotIn(None, sentenceAttributes) sentenceContents = self.protocol._SENTENCE_CONTENTS sentenceSpecAttributes = itertools.chain(*sentenceContents.values()) self.assertIn(None, sentenceSpecAttributes)
mailAttachment.ts
/** * Mail Baby API * This is an API defintion for accesssing the Mail.Baby mail service. * * The version of the OpenAPI document: 1.0.0 * Contact: [email protected] * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). * https://openapi-generator.tech * Do not edit the class manually. */
/** * A File attachment for an email */ export interface MailAttachment { /** * Contents of the attached file */ data: Blob; /** * Optional filename to specify for the attachment. */ filename?: string; }
icon_insights.rs
pub struct IconInsights { props: crate::Props, } impl yew::Component for IconInsights { type Properties = crate::Props; type Message = (); fn create(props: Self::Properties, _: yew::prelude::ComponentLink<Self>) -> Self
fn update(&mut self, _: Self::Message) -> yew::prelude::ShouldRender { true } fn change(&mut self, _: Self::Properties) -> yew::prelude::ShouldRender { false } fn view(&self) -> yew::prelude::Html { yew::prelude::html! { <svg class=self.props.class.unwrap_or("") width=self.props.size.unwrap_or(24).to_string() height=self.props.size.unwrap_or(24).to_string() viewBox="0 0 24 24" fill=self.props.fill.unwrap_or("none") stroke=self.props.color.unwrap_or("currentColor") stroke-width=self.props.stroke_width.unwrap_or(2).to_string() stroke-linecap=self.props.stroke_linecap.unwrap_or("round") stroke-linejoin=self.props.stroke_linejoin.unwrap_or("round") > <svg xmlns="http://www.w3.org/2000/svg" enable-background="new 0 0 24 24" height="24" viewBox="0 0 24 24" width="24"><g><rect fill="none" height="24" width="24"/><rect fill="none" height="24" width="24"/></g><g><g><path d="M21,8c-1.45,0-2.26,1.44-1.93,2.51l-3.55,3.56c-0.3-0.09-0.74-0.09-1.04,0l-2.55-2.55C12.27,10.45,11.46,9,10,9 c-1.45,0-2.27,1.44-1.93,2.52l-4.56,4.55C2.44,15.74,1,16.55,1,18c0,1.1,0.9,2,2,2c1.45,0,2.26-1.44,1.93-2.51l4.55-4.56 c0.3,0.09,0.74,0.09,1.04,0l2.55,2.55C12.73,16.55,13.54,18,15,18c1.45,0,2.27-1.44,1.93-2.52l3.56-3.55 C21.56,12.26,23,11.45,23,10C23,8.9,22.1,8,21,8z"/><polygon points="15,9 15.94,6.93 18,6 15.94,5.07 15,3 14.08,5.07 12,6 14.08,6.93"/><polygon points="3.5,11 4,9 6,8.5 4,8 3.5,6 3,8 1,8.5 3,9"/></g></g></svg> </svg> } } }
{ Self { props } }
latexAUXFile.js
import {Format} from "../../Format.js"; export class
extends Format { name = "Latex Auxiliary File"; ext = [".aux"]; forbidExtMatch = true; magic = ["LaTeX auxiliary file"]; weakMagic = true; untouched = true; metaProvider = ["text"]; }
latexAUXFile
pytest_yamlsound.py
import yaml, pytest def pytest_collect_file(parent, path): if path.ext == ".yml" and path.basename.startswith("test"): return YamlFile.from_parent(parent, fspath=path) class YamlException(Exception): """Custom exception for error reporting.""" class YamlFile(pytest.File): def collect(self): raw = yaml.safe_load(self.fspath.open()) for spec in raw: name = spec["name"] yield YamlItem.from_parent(self, name=name, spec=spec) class YamlItem(pytest.Item): def __init__(self, name, parent, spec): super().__init__(name, parent) self.spec = spec def runtest(self): test_type = self.spec.get("type") if test_type != "check-compression": raise YamlException(f"unknown test type: {test_type}") codec = self.spec.get("codec") if codec != "mp3": raise YamlException(f"unknown codec: {codec}") # pseudo check inputfile = self.spec.get("inputfile") compression = self.spec.get("compression") real_comp = "15%" if compression != real_comp: raise YamlException( f"compression of {inputfile} was {real_comp}, " f"expected {compression}") def repr_failure(self, excinfo): """Called when self.runtest() raises an exception.""" if isinstance(excinfo.value, YamlException): return f"spec failed: {excinfo.value}" return super().repr_failure(excinfo)
def reportinfo(self): return self.fspath, 0, f"usecase: {self.name}"
garf_data.py
import json, os class GarfData: file = os.path.join(os.getcwd(), "garf_data.json") token: str path_to_ffmpeg: str jokes: list trigger_words: list def __init__(self): with open(self.file, "r") as f: json_dict = json.loads(f.read()) self.token = json_dict["token"] self.path_to_ffmpeg = json_dict["path_to_ffmpeg"] self.jokes = json_dict["jokes"] self.trigger_words = json_dict["trigger_words"]
"path_to_ffmpeg": self.path_to_ffmpeg, "jokes": self.jokes, "trigger_words": self.trigger_words } with open(self.file, "w") as f: f.write(json.dumps(json_dict, indent = 4) + os.linesep)
def overwrite(self): json_dict = { "token": self.token,
admin.py
from .models import Choice from .models import Question from django.contrib import admin # Register your models here. class ChoiceInline(admin.TabularInline): model = Choice extra = 1 class QuestionAdmin(admin.ModelAdmin):
admin.site.register(Question, QuestionAdmin)
fieldsets = [ (None, {'fields': ['question_text']}), ('Date information', {'fields': ['pub_date']}), ] inlines = [ChoiceInline] list_display = ('question_text', 'pub_date', 'was_published_recently') list_filter = ['pub_date'] search_fields = ['question_text']
harness_controller.py
#!/usr/bin/env python # # Copyright (c) 2016, The OpenThread Authors. # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # 3. Neither the name of the copyright holder nor the # names of its contributors may be used to endorse or promote products # derived from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # import ConfigParser import logging import os import subprocess import time from autothreadharness import settings logger = logging.getLogger(__name__) HARNESS_SVN_VERSION_R44 = 1471 """int: this is the first published release that miniweb was removed from Harness""" def _try_kill(proc): logger.info('Try kill process') times = 1 while proc.poll() is None: proc.kill() time.sleep(5) if proc.poll() is not None: logger.info('Process has been killed') break logger.info('Trial %d failed', times) times += 1 if times > 3:
class HarnessController(object): """Harness service control This controls harness service, including the harness back-end and front-end. """ harness = None """harness back-end""" miniweb = None """harness front-end""" def __init__(self, result_dir=None): self.result_dir = result_dir self.harness_file = '' harness_info = ConfigParser.ConfigParser() harness_info.read('%s\\info.ini' % settings.HARNESS_HOME) self.version = harness_info.getint('Thread_Harness_Info', 'SVN') def start(self): logger.info('Starting harness service') if self.harness: logger.warning('Harness already started') else: env = dict(os.environ, PYTHONPATH='%s\\Thread_Harness;%s\\ThirdParty\\hsdk-python\\src' % (settings.HARNESS_HOME, settings.HARNESS_HOME)) self.harness_file = '%s\\harness-%s.log' % (self.result_dir, time.strftime('%Y%m%d%H%M%S')) with open(self.harness_file, 'w') as harness_out: self.harness = subprocess.Popen([settings.HARNESS_HOME + '\\Python27\\python.exe', settings.HARNESS_HOME + '\\Thread_Harness\\Run.py'], cwd=settings.HARNESS_HOME, stdout=harness_out, stderr=harness_out, env=env) time.sleep(2) if self.version >= HARNESS_SVN_VERSION_R44: return if self.miniweb: logger.warning('Miniweb already started') else: with open('%s\\miniweb-%s.log' % (self.result_dir, time.strftime('%Y%m%d%H%M%S')), 'w') as miniweb_out: self.miniweb = subprocess.Popen([settings.HARNESS_HOME + '\\MiniWeb\\miniweb.exe'], stdout=miniweb_out, stderr=miniweb_out, cwd=settings.HARNESS_HOME + '\\MiniWeb') def stop(self): logger.info('Stopping harness service') if self.harness: _try_kill(self.harness) self.harness = None else: logger.warning('Harness not started yet') if self.version >= HARNESS_SVN_VERSION_R44: return if self.miniweb: _try_kill(self.miniweb) self.miniweb = None else: logger.warning('Miniweb not started yet') def tail(self): with open(self.harness_file) as harness_out: harness_out.seek(-100, 2) return ''.join(harness_out.readlines()) def __del__(self): self.stop()
raise SystemExit()
models.py
# Copyright 2014 Rackspace # Copyright 2016 Blue Box, an IBM Company # Copyright 2017 Walmart Stores Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_db.sqlalchemy import models import sqlalchemy as sa from sqlalchemy.ext import orderinglist from sqlalchemy import orm from sqlalchemy.orm import validates from sqlalchemy.sql import func from octavia.api.v2.types import amphora from octavia.api.v2.types import availability_zone_profile from octavia.api.v2.types import availability_zones from octavia.api.v2.types import flavor_profile from octavia.api.v2.types import flavors from octavia.api.v2.types import health_monitor from octavia.api.v2.types import l7policy from octavia.api.v2.types import l7rule from octavia.api.v2.types import listener from octavia.api.v2.types import load_balancer from octavia.api.v2.types import member from octavia.api.v2.types import pool from octavia.api.v2.types import quotas from octavia.common import constants from octavia.common import data_models from octavia.db import base_models from octavia.i18n import _ class ProvisioningStatus(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "provisioning_status" class OperatingStatus(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "operating_status" class Protocol(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "protocol" class Algorithm(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "algorithm" class AmphoraRoles(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "amphora_roles" class LBTopology(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "lb_topology" class SessionPersistenceType(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "session_persistence_type" class HealthMonitorType(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "health_monitor_type" class VRRPAuthMethod(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "vrrp_auth_method" class L7RuleType(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "l7rule_type" class L7RuleCompareType(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "l7rule_compare_type" class L7PolicyAction(base_models.BASE, base_models.LookupTableMixin): __tablename__ = "l7policy_action" class AmphoraBuildSlots(base_models.BASE): __tablename__ = "amphora_build_slots" id = sa.Column(sa.Integer(), primary_key=True) slots_used = sa.Column(sa.Integer()) class AmphoraBuildRequest(base_models.BASE): __tablename__ = "amphora_build_request" amphora_id = sa.Column(sa.String(36), nullable=True, primary_key=True) priority = sa.Column(sa.Integer()) created_time = sa.Column(sa.DateTime, default=func.now(), nullable=False) status = sa.Column(sa.String(16), default='WAITING', nullable=False) class SessionPersistence(base_models.BASE): __data_model__ = data_models.SessionPersistence __tablename__ = "session_persistence" pool_id = sa.Column( sa.String(36), sa.ForeignKey("pool.id", name="fk_session_persistence_pool_id"), nullable=False, primary_key=True) type = sa.Column( sa.String(36), sa.ForeignKey( "session_persistence_type.name", name="fk_session_persistence_session_persistence_type_name"), nullable=False) cookie_name = sa.Column(sa.String(255), nullable=True) persistence_timeout = sa.Column(sa.Integer(), nullable=True) persistence_granularity = sa.Column(sa.String(64), nullable=True) pool = orm.relationship("Pool", uselist=False, back_populates="session_persistence") class ListenerStatistics(base_models.BASE): __data_model__ = data_models.ListenerStatistics __tablename__ = "listener_statistics" listener_id = sa.Column( sa.String(36), primary_key=True, nullable=False) amphora_id = sa.Column( sa.String(36), primary_key=True, nullable=False) bytes_in = sa.Column(sa.BigInteger, nullable=False) bytes_out = sa.Column(sa.BigInteger, nullable=False) active_connections = sa.Column(sa.Integer, nullable=False) total_connections = sa.Column(sa.BigInteger, nullable=False) request_errors = sa.Column(sa.BigInteger, nullable=False) @validates('bytes_in', 'bytes_out', 'active_connections', 'total_connections', 'request_errors') def validate_non_negative_int(self, key, value): if value < 0: data = {'key': key, 'value': value} raise ValueError(_('The %(key)s field can not have ' 'negative value. ' 'Current value is %(value)d.') % data) return value class Member(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.Member __tablename__ = "member" __v2_wsme__ = member.MemberResponse __table_args__ = ( sa.UniqueConstraint('pool_id', 'ip_address', 'protocol_port', name='uq_member_pool_id_address_protocol_port'), ) pool_id = sa.Column( sa.String(36), sa.ForeignKey("pool.id", name="fk_member_pool_id"), nullable=False) subnet_id = sa.Column(sa.String(36), nullable=True) ip_address = sa.Column('ip_address', sa.String(64), nullable=False) protocol_port = sa.Column(sa.Integer, nullable=False) weight = sa.Column(sa.Integer, nullable=True) backup = sa.Column(sa.Boolean(), nullable=False) monitor_address = sa.Column(sa.String(64), nullable=True) monitor_port = sa.Column(sa.Integer, nullable=True) provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_member_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_member_operating_status_name"), nullable=False) enabled = sa.Column(sa.Boolean(), nullable=False) pool = orm.relationship("Pool", back_populates="members") _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==Member.id)' ) class HealthMonitor(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.HealthMonitor __tablename__ = "health_monitor" __v2_wsme__ = health_monitor.HealthMonitorResponse __table_args__ = ( sa.UniqueConstraint('pool_id', name='uq_health_monitor_pool'), ) type = sa.Column( sa.String(36), sa.ForeignKey("health_monitor_type.name", name="fk_health_monitor_health_monitor_type_name"), nullable=False) pool_id = sa.Column( sa.String(36), sa.ForeignKey("pool.id", name="fk_health_monitor_pool_id"), nullable=False) delay = sa.Column(sa.Integer, nullable=False) timeout = sa.Column(sa.Integer, nullable=False) fall_threshold = sa.Column(sa.Integer, nullable=False) rise_threshold = sa.Column(sa.Integer, nullable=False) http_method = sa.Column(sa.String(16), nullable=True) url_path = sa.Column(sa.String(2048), nullable=True) expected_codes = sa.Column(sa.String(64), nullable=True) enabled = sa.Column(sa.Boolean, nullable=False) pool = orm.relationship("Pool", uselist=False, back_populates="health_monitor") provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_health_monitor_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_health_monitor_operating_status_name"), nullable=False) _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==HealthMonitor.id)' ) http_version = sa.Column(sa.Float, nullable=True) domain_name = sa.Column(sa.String(255), nullable=True) class Pool(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.Pool __tablename__ = "pool" __v2_wsme__ = pool.PoolResponse description = sa.Column(sa.String(255), nullable=True) protocol = sa.Column( sa.String(16), sa.ForeignKey("protocol.name", name="fk_pool_protocol_name"), nullable=False) lb_algorithm = sa.Column( sa.String(255), sa.ForeignKey("algorithm.name", name="fk_pool_algorithm_name"), nullable=False) provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_pool_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_pool_operating_status_name"), nullable=False) enabled = sa.Column(sa.Boolean, nullable=False) load_balancer_id = sa.Column( sa.String(36), sa.ForeignKey("load_balancer.id", name="fk_pool_load_balancer_id"), nullable=True) health_monitor = orm.relationship("HealthMonitor", uselist=False, cascade="delete", back_populates="pool") load_balancer = orm.relationship("LoadBalancer", uselist=False, back_populates="pools") members = orm.relationship("Member", uselist=True, cascade="delete", back_populates="pool") session_persistence = orm.relationship( "SessionPersistence", uselist=False, cascade="delete", back_populates="pool") _default_listeners = orm.relationship("Listener", uselist=True, back_populates="default_pool") l7policies = orm.relationship("L7Policy", uselist=True, back_populates="redirect_pool") _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==Pool.id)' ) tls_certificate_id = sa.Column(sa.String(255), nullable=True) ca_tls_certificate_id = sa.Column(sa.String(255), nullable=True) crl_container_id = sa.Column(sa.String(255), nullable=True) tls_enabled = sa.Column(sa.Boolean, default=False, nullable=False) # This property should be a unique list of any listeners that reference # this pool as its default_pool and any listeners referenced by enabled # L7Policies with at least one l7rule which also reference this pool. The # intent is that pool.listeners should be a unique list of listeners # *actually* using the pool. @property def listeners(self): _listeners = self._default_listeners[:] _l_ids = [l.id for l in _listeners] l7_listeners = [p.listener for p in self.l7policies if len(p.l7rules) > 0 and p.enabled is True] for l in l7_listeners: if l.id not in _l_ids: _listeners.append(l) _l_ids.append(l.id) return _listeners class LoadBalancer(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.LoadBalancer __tablename__ = "load_balancer" __v2_wsme__ = load_balancer.LoadBalancerResponse description = sa.Column(sa.String(255), nullable=True) provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_load_balancer_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_load_balancer_operating_status_name"), nullable=False) topology = sa.Column( sa.String(36), sa.ForeignKey("lb_topology.name", name="fk_lb_topology_name"), nullable=True) enabled = sa.Column(sa.Boolean, nullable=False) amphorae = orm.relationship("Amphora", uselist=True, back_populates="load_balancer") server_group_id = sa.Column(sa.String(36), nullable=True) provider = sa.Column(sa.String(64), nullable=True) vip = orm.relationship('Vip', cascade='delete', uselist=False, backref=orm.backref('load_balancer', uselist=False)) pools = orm.relationship('Pool', cascade='delete', uselist=True, back_populates="load_balancer") listeners = orm.relationship('Listener', cascade='delete', uselist=True, back_populates='load_balancer') _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==LoadBalancer.id)' ) flavor_id = sa.Column( sa.String(36), sa.ForeignKey("flavor.id", name="fk_lb_flavor_id"), nullable=True) availability_zone = sa.Column( sa.String(255), sa.ForeignKey("availability_zone.name", name="fk_load_balancer_availability_zone_name"), nullable=True) class VRRPGroup(base_models.BASE): __data_model__ = data_models.VRRPGroup __tablename__ = "vrrp_group" load_balancer_id = sa.Column( sa.String(36), sa.ForeignKey("load_balancer.id", name="fk_vrrp_group_load_balancer_id"), nullable=False, primary_key=True) vrrp_group_name = sa.Column(sa.String(36), nullable=True) vrrp_auth_type = sa.Column(sa.String(16), sa.ForeignKey( "vrrp_auth_method.name", name="fk_load_balancer_vrrp_auth_method_name")) vrrp_auth_pass = sa.Column(sa.String(36), nullable=True) advert_int = sa.Column(sa.Integer(), nullable=True) load_balancer = orm.relationship("LoadBalancer", uselist=False, backref=orm.backref("vrrp_group", uselist=False, cascade="delete")) class Vip(base_models.BASE): __data_model__ = data_models.Vip __tablename__ = "vip" load_balancer_id = sa.Column( sa.String(36), sa.ForeignKey("load_balancer.id", name="fk_vip_load_balancer_id"), nullable=False, primary_key=True) ip_address = sa.Column(sa.String(64), nullable=True) port_id = sa.Column(sa.String(36), nullable=True) subnet_id = sa.Column(sa.String(36), nullable=True) network_id = sa.Column(sa.String(36), nullable=True) qos_policy_id = sa.Column(sa.String(36), nullable=True) octavia_owned = sa.Column(sa.Boolean(), nullable=True) class Listener(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.Listener __tablename__ = "listener" __v2_wsme__ = listener.ListenerResponse __table_args__ = ( sa.UniqueConstraint( 'load_balancer_id', 'protocol', 'protocol_port', name='uq_listener_load_balancer_id_protocol_port'), ) description = sa.Column(sa.String(255), nullable=True) protocol = sa.Column( sa.String(16), sa.ForeignKey("protocol.name", name="fk_listener_protocol_name"), nullable=False) protocol_port = sa.Column(sa.Integer(), nullable=False) connection_limit = sa.Column(sa.Integer, nullable=True) load_balancer_id = sa.Column( sa.String(36), sa.ForeignKey("load_balancer.id", name="fk_listener_load_balancer_id"), nullable=True) tls_certificate_id = sa.Column(sa.String(255), nullable=True) default_pool_id = sa.Column( sa.String(36), sa.ForeignKey("pool.id", name="fk_listener_pool_id"), nullable=True) provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_listener_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_listener_operating_status_name"), nullable=False) enabled = sa.Column(sa.Boolean(), nullable=False) load_balancer = orm.relationship("LoadBalancer", uselist=False, back_populates="listeners") default_pool = orm.relationship("Pool", uselist=False, back_populates="_default_listeners") sni_containers = orm.relationship( 'SNI', cascade='delete', uselist=True, backref=orm.backref('listener', uselist=False)) l7policies = orm.relationship( 'L7Policy', uselist=True, order_by='L7Policy.position', collection_class=orderinglist.ordering_list('position', count_from=1), cascade='delete', back_populates='listener') peer_port = sa.Column(sa.Integer(), nullable=True) insert_headers = sa.Column(sa.PickleType()) timeout_client_data = sa.Column(sa.Integer, nullable=True) timeout_member_connect = sa.Column(sa.Integer, nullable=True) timeout_member_data = sa.Column(sa.Integer, nullable=True) timeout_tcp_inspect = sa.Column(sa.Integer, nullable=True) client_ca_tls_certificate_id = sa.Column(sa.String(255), nullable=True) client_authentication = sa.Column( sa.String(10), sa.ForeignKey("client_authentication_mode.name", name="fk_listener_client_authentication_mode_name"), nullable=False, default=constants.CLIENT_AUTH_NONE) client_crl_container_id = sa.Column(sa.String(255), nullable=True) _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==Listener.id)' ) # This property should be a unique list of the default_pool and anything # referenced by enabled L7Policies with at least one rule that also # reference this listener. The intent is that listener.pools should be a # unique list of pools this listener is *actually* using. @property def pools(self): _pools = [] _p_ids = [] if self.default_pool: _pools.append(self.default_pool) _p_ids.append(self.default_pool.id) l7_pools = [p.redirect_pool for p in self.l7policies if p.redirect_pool is not None and len(p.l7rules) > 0 and p.enabled is True] for p in l7_pools: if p.id not in _p_ids: _pools.append(p) _p_ids.append(p.id) return _pools allowed_cidrs = orm.relationship( 'ListenerCidr', cascade='all,delete-orphan', uselist=True, backref=orm.backref('listener', uselist=False)) class SNI(base_models.BASE): __data_model__ = data_models.SNI __tablename__ = "sni" __table_args__ = ( sa.PrimaryKeyConstraint('listener_id', 'tls_container_id'), ) listener_id = sa.Column( sa.String(36), sa.ForeignKey("listener.id", name="fk_sni_listener_id"), nullable=False) tls_container_id = sa.Column(sa.String(128), nullable=False) position = sa.Column(sa.Integer(), nullable=True) class Amphora(base_models.BASE, base_models.IdMixin, models.TimestampMixin): __data_model__ = data_models.Amphora __tablename__ = "amphora" __v2_wsme__ = amphora.AmphoraResponse load_balancer_id = sa.Column( sa.String(36), sa.ForeignKey("load_balancer.id", name="fk_amphora_load_balancer_id"), nullable=True) compute_id = sa.Column(sa.String(36), nullable=True) lb_network_ip = sa.Column(sa.String(64), nullable=True) vrrp_ip = sa.Column(sa.String(64), nullable=True) ha_ip = sa.Column(sa.String(64), nullable=True) vrrp_port_id = sa.Column(sa.String(36), nullable=True) ha_port_id = sa.Column(sa.String(36), nullable=True) cert_expiration = sa.Column(sa.DateTime(timezone=True), default=None, nullable=True) cert_busy = sa.Column(sa.Boolean(), default=False, nullable=False) role = sa.Column( sa.String(36), sa.ForeignKey("amphora_roles.name", name="fk_amphora_roles_name"), nullable=True) status = sa.Column( sa.String(36), sa.ForeignKey("provisioning_status.name", name="fk_container_provisioning_status_name")) vrrp_interface = sa.Column(sa.String(16), nullable=True) vrrp_id = sa.Column(sa.Integer(), nullable=True) vrrp_priority = sa.Column(sa.Integer(), nullable=True) cached_zone = sa.Column(sa.String(255), nullable=True) image_id = sa.Column(sa.String(36), nullable=True) load_balancer = orm.relationship("LoadBalancer", uselist=False, back_populates='amphorae') compute_flavor = sa.Column(sa.String(255), nullable=True) class AmphoraHealth(base_models.BASE): __data_model__ = data_models.AmphoraHealth __tablename__ = "amphora_health" amphora_id = sa.Column( sa.String(36), nullable=False, primary_key=True) last_update = sa.Column(sa.DateTime, default=func.now(), nullable=False) busy = sa.Column(sa.Boolean(), default=False, nullable=False) class L7Rule(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.TagMixin): __data_model__ = data_models.L7Rule __tablename__ = "l7rule" __v2_wsme__ = l7rule.L7RuleResponse l7policy_id = sa.Column( sa.String(36), sa.ForeignKey("l7policy.id", name="fk_l7rule_l7policy_id"), nullable=False) type = sa.Column( sa.String(36), sa.ForeignKey( "l7rule_type.name", name="fk_l7rule_l7rule_type_name"), nullable=False) compare_type = sa.Column( sa.String(36), sa.ForeignKey( "l7rule_compare_type.name", name="fk_l7rule_l7rule_compare_type_name"), nullable=False) key = sa.Column(sa.String(255), nullable=True) value = sa.Column(sa.String(255), nullable=False) invert = sa.Column(sa.Boolean(), default=False, nullable=False) enabled = sa.Column(sa.Boolean(), nullable=False) l7policy = orm.relationship("L7Policy", uselist=False, back_populates="l7rules") provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_l7rule_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_l7rule_operating_status_name"), nullable=False) _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==L7Rule.id)' ) class L7Policy(base_models.BASE, base_models.IdMixin, base_models.ProjectMixin, models.TimestampMixin, base_models.NameMixin, base_models.TagMixin): __data_model__ = data_models.L7Policy __tablename__ = "l7policy" __v2_wsme__ = l7policy.L7PolicyResponse description = sa.Column(sa.String(255), nullable=True) listener_id = sa.Column( sa.String(36), sa.ForeignKey("listener.id", name="fk_l7policy_listener_id"), nullable=False) action = sa.Column( sa.String(36), sa.ForeignKey( "l7policy_action.name", name="fk_l7policy_l7policy_action_name"), nullable=False) redirect_pool_id = sa.Column( sa.String(36), sa.ForeignKey("pool.id", name="fk_l7policy_pool_id"), nullable=True) redirect_url = sa.Column( sa.String(255), nullable=True) redirect_prefix = sa.Column( sa.String(255), nullable=True) redirect_http_code = sa.Column(sa.Integer, nullable=True) position = sa.Column(sa.Integer, nullable=False) enabled = sa.Column(sa.Boolean(), nullable=False) listener = orm.relationship("Listener", uselist=False, back_populates="l7policies") redirect_pool = orm.relationship("Pool", uselist=False, back_populates="l7policies") l7rules = orm.relationship("L7Rule", uselist=True, cascade="delete", back_populates="l7policy") provisioning_status = sa.Column( sa.String(16), sa.ForeignKey("provisioning_status.name", name="fk_l7policy_provisioning_status_name"), nullable=False) operating_status = sa.Column( sa.String(16), sa.ForeignKey("operating_status.name", name="fk_l7policy_operating_status_name"), nullable=False) _tags = orm.relationship( 'Tags', single_parent=True, lazy='subquery', cascade='all,delete-orphan', primaryjoin='and_(foreign(Tags.resource_id)==L7Policy.id)' ) class Quotas(base_models.BASE): __data_model__ = data_models.Quotas __tablename__ = "quotas" __v2_wsme__ = quotas.QuotaAllBase project_id = sa.Column(sa.String(36), primary_key=True) health_monitor = sa.Column(sa.Integer(), nullable=True) listener = sa.Column(sa.Integer(), nullable=True) load_balancer = sa.Column(sa.Integer(), nullable=True) member = sa.Column(sa.Integer(), nullable=True) pool = sa.Column(sa.Integer(), nullable=True) in_use_health_monitor = sa.Column(sa.Integer(), nullable=True) in_use_listener = sa.Column(sa.Integer(), nullable=True) in_use_load_balancer = sa.Column(sa.Integer(), nullable=True) in_use_member = sa.Column(sa.Integer(), nullable=True) in_use_pool = sa.Column(sa.Integer(), nullable=True) class FlavorProfile(base_models.BASE, base_models.IdMixin, base_models.NameMixin): __data_model__ = data_models.FlavorProfile __tablename__ = "flavor_profile" __v2_wsme__ = flavor_profile.FlavorProfileResponse provider_name = sa.Column(sa.String(255), nullable=False) flavor_data = sa.Column(sa.String(4096), nullable=False) class Flavor(base_models.BASE, base_models.IdMixin, base_models.NameMixin): __data_model__ = data_models.Flavor __tablename__ = "flavor" __v2_wsme__ = flavors.FlavorResponse __table_args__ = ( sa.UniqueConstraint('name', name='uq_flavor_name'), ) description = sa.Column(sa.String(255), nullable=True) enabled = sa.Column(sa.Boolean(), nullable=False) flavor_profile_id = sa.Column( sa.String(36), sa.ForeignKey("flavor_profile.id", name="fk_flavor_flavor_profile_id"), nullable=False) class AvailabilityZoneProfile(base_models.BASE, base_models.IdMixin,
__data_model__ = data_models.AvailabilityZoneProfile __tablename__ = "availability_zone_profile" __v2_wsme__ = availability_zone_profile.AvailabilityZoneProfileResponse provider_name = sa.Column(sa.String(255), nullable=False) availability_zone_data = sa.Column(sa.String(4096), nullable=False) class AvailabilityZone(base_models.BASE, base_models.NameMixin): __data_model__ = data_models.AvailabilityZone __tablename__ = "availability_zone" __v2_wsme__ = availability_zones.AvailabilityZoneResponse __table_args__ = ( sa.PrimaryKeyConstraint('name'), ) description = sa.Column(sa.String(255), nullable=True) enabled = sa.Column(sa.Boolean(), nullable=False) availability_zone_profile_id = sa.Column( sa.String(36), sa.ForeignKey("availability_zone_profile.id", name="fk_az_az_profile_id"), nullable=False) class ClientAuthenticationMode(base_models.BASE): __tablename__ = "client_authentication_mode" name = sa.Column(sa.String(10), primary_key=True, nullable=False) class SparesPool(base_models.BASE): __tablename__ = "spares_pool" updated_at = sa.Column(sa.DateTime, primary_key=True, nullable=True) class ListenerCidr(base_models.BASE): __data_model__ = data_models.ListenerCidr __tablename__ = "listener_cidr" __table_args__ = ( sa.PrimaryKeyConstraint('listener_id', 'cidr'), ) listener_id = sa.Column( sa.String(36), sa.ForeignKey("listener.id", name="fk_listener_cidr_listener_id"), nullable=False) cidr = sa.Column(sa.String(64), nullable=False)
base_models.NameMixin):
set_commands_enabled.rs
use packet_derive::{packet, MCPEPacketDataAuto}; #[packet(0x3B)] #[derive(MCPEPacketDataAuto)] pub struct
{ enabled: bool, }
SetCommandsEnabledPacket
game.rs
use crate::assets::{ImageId, Images}; use crate::components::{Position, Velocity}; use crate::gl::Gl; use crate::input_system::{BunnyCount, InputEvent, InputSystem}; use crate::move_system::MoveSystem; use crate::render_system::{DisplayEvent, RenderSystem, Sprite, Transform, WindowSize}; use anyhow::Result; use rand::Rng; use specs::prelude::*; use specs::shrev::EventChannel; use std::rc::Rc; use std::sync::Mutex; use vek::Vec2; use wasm_bindgen::closure::Closure; use wasm_bindgen::JsCast; use web_sys::Window; pub struct Game { gl: Rc<Gl>, images: Rc<Images>, dom_event_handlers: DomEvents, world: World, input_system: InputSystem, move_system: MoveSystem, render_system: RenderSystem, } impl Game { pub async fn init(gl: Rc<Gl>, window: &Window, canvas_size: Vec2<i32>) -> Result<Self> { let images = load_images(gl.clone()).await?; let images = Rc::new(images); let bunny_image = images.find_image_id("/assets/images/bunny.png").unwrap(); let mut world = init_world(canvas_size, &images); Ok(Game { gl: gl.clone(), images: Rc::new(Images::new(gl.clone())), dom_event_handlers: DomEvents::register(window), input_system: InputSystem::new(images.clone(), &mut world, bunny_image), render_system: RenderSystem::new(gl.clone(), &images, &world, canvas_size), move_system: MoveSystem, world, }) } pub fn process_events(&mut self) { let mut channel = self.world.fetch_mut::<EventChannel<InputEvent>>(); self.dom_event_handlers.process_input(&mut channel); } pub fn bunny_count(&self) -> u32 { self.world.fetch::<BunnyCount>().0 } pub fn run_world(&mut self, canvas_size: Vec2<i32>) { { let mut window_size = self.world.fetch_mut::<WindowSize>(); window_size.size = canvas_size; } self.input_system.run_now(&mut self.world); self.move_system.run_now(&mut self.world); self.render_system.run_now(&mut self.world); self.world.maintain(); } } async fn load_images(gl: Rc<Gl>) -> Result<Images> { let mut images = Images::new(gl); images.load("/assets/images/bunny.png").await?; Ok(images) } fn init_world(canvas_size: Vec2<i32>, images: &Images) -> World { let mut world = World::new(); world.register::<Position>(); world.register::<Velocity>(); world.register::<Transform>(); world.register::<Sprite>(); world.insert(EventChannel::<DisplayEvent>::new()); world.insert(EventChannel::<InputEvent>::new()); world.insert(WindowSize { size: canvas_size }); world.insert(BunnyCount(3)); let mut rng = rand::thread_rng(); let bunny_id = images.find_image_id("/assets/images/bunny.png").unwrap(); let bunny_image = images.image(bunny_id).unwrap(); for _ in 0..3 { let x: i32 = rng.gen_range(0, canvas_size.x); let y: i32 = rng.gen_range(0, canvas_size.y); world .create_entity() .with(Position::new(x as f32, y as f32)) .with(Velocity::from_angle( rng.gen_range(-std::f32::consts::PI, std::f32::consts::PI), 4., )) .with(Transform::from_image(&bunny_image)) .with(Sprite::from_image(bunny_id)) .build(); } world } struct DomEvents { mouse_down: Closure<dyn Fn()>, mouse_up: Closure<dyn Fn()>, input_events: Rc<Mutex<Vec<InputEvent>>>, } impl DomEvents { pub fn register(window: &Window) -> Self { let input_events = Rc::new(Mutex::new(Vec::<InputEvent>::new())); let events = input_events.clone(); let mouse_down = Closure::wrap(Box::new(move || { let mut evs = events.lock().unwrap(); evs.push(InputEvent::MouseDown); }) as Box<dyn Fn()>); window .add_event_listener_with_callback("mousedown", mouse_down.as_ref().unchecked_ref()) .unwrap(); let events = input_events.clone(); let mouse_up = Closure::wrap(Box::new(move || { let mut evs = events.lock().unwrap(); evs.push(InputEvent::MouseUp); }) as Box<dyn Fn()>); window .add_event_listener_with_callback("mouseup", mouse_up.as_ref().unchecked_ref()) .unwrap(); DomEvents { mouse_down, mouse_up, input_events, } } pub fn process_input(&self, channel: &mut EventChannel<InputEvent>)
pub fn clear(&mut self) { self.input_events.lock().unwrap().clear(); } }
{ let mut events = self.input_events.lock().unwrap(); channel.drain_vec_write(&mut events); }
handle.rs
use std::{ops::Deref, sync::Arc}; use crate::assets::Asset; #[derive(Debug)] pub struct Handle<A: Asset> {
impl<A: Asset> Handle<A> { pub(crate) fn new(data: Arc<A>) -> Self { Self { data } } } impl<A: Asset> Deref for Handle<A> { type Target = A; fn deref(&self) -> &Self::Target { self.data.as_ref() } }
data: Arc<A>, }
test_fx.py
# Owner(s): ["oncall: fx"] import builtins import contextlib import copy import functools import inspect import math import numbers import operator import os import pickle import sys import torch import traceback import typing import types import warnings import unittest from math import sqrt from torch.multiprocessing import Process from torch.testing import FileCheck from torch.testing._internal.common_methods_invocations import op_db from torch.testing._internal.common_device_type import ops, onlyCPU, instantiate_device_type_tests import torch.utils._pytree as pytree import torch.fx._pytree as fx_pytree from torch.fx import symbolic_trace, Proxy, Node, GraphModule, Interpreter, Tracer, Transformer, Graph, wrap, PH, CodeGen from torch.fx.node import Target, Argument from torch.fx.passes import shape_prop from torch.fx.immutable_collections import immutable_dict, immutable_list from torch.fx.experimental.rewriter import RewritingTracer from torch.fx.operator_schemas import get_signature_for_torch_op from copy import deepcopy from collections import namedtuple from torch.fx.proxy import TraceError from torch.fx._compatibility import _BACK_COMPAT_OBJECTS, _MARKED_WITH_COMATIBLITY from fx.test_subgraph_rewriter import TestSubgraphRewriter # noqa: F401 from fx.test_dce_pass import TestDCE # noqa: F401 from fx.test_fx_const_fold import TestConstFold # noqa: F401 from fx.test_fx_param_shape_control_flow import TestConstParamShapeInControlFlow # noqa: F401 if sys.version_info >= (3, 7): from fx.test_gradual_type import AnnotationsTest # noqa: F401 if sys.version_info >= (3, 7): from fx.test_gradual_type import TypeCheckerTest # noqa: F401 from typing import Any, Callable, Dict, NamedTuple, List, Optional, Tuple, Union from torch.testing._internal.common_utils import ( IS_FBCODE, IS_MACOS, IS_WINDOWS, TEST_WITH_ROCM, find_library_location, run_tests, ) from torch.testing._internal.jit_utils import JitTestCase from fx.named_tup import MyNamedTup try: from torchvision import models as torchvision_models HAS_TORCHVISION = True except ImportError: HAS_TORCHVISION = False skipIfNoTorchVision = unittest.skipIf(not HAS_TORCHVISION, "no torchvision") class SimpleTest(torch.nn.Module): def forward(self, x): return torch.relu(x + 3.0) def a_non_torch_leaf(a, b): return a + b # Used for test_autowrap_function. Autowrapped functions need to be global def fx_int(x: float) -> int: return int(x) def fx_int_x2(x: float) -> int: return int(x) * 2 # used in test_pytree. It's all the way out here because pickling a GraphModule # that uses Point errors out if Point is local to the function Point = namedtuple('Point', ['x', 'y']) # Test wrap() passing both a function name as well as a function # directly def a_lifted_leaf(a, b): return a[0] + a[1] + b wrap('a_lifted_leaf') # Test wrapping twice doesn't break anything wrap('a_lifted_leaf') def a_lifted_leaf2(a, b): return a[0] + a[1] + b wrap(a_lifted_leaf2) wrap('len') wrap('getattr') @wrap def wrapped_via_decorator(a): return a + 1 wrap('wrapped_with_submodule') def wrapped_with_submodule(x: torch.Tensor, batchnorm1d: torch.nn.BatchNorm1d): return batchnorm1d(x) real_wrapped_via_decorator = wrapped_via_decorator real_a_lifed_leaf = a_lifted_leaf real_a_lifed_leaf2 = a_lifted_leaf2 _sqrt = sqrt wrap('wrapper_fn') def wrapper_fn(x): return torch.foo(x) class Pair(NamedTuple): x : torch.Tensor y : torch.Tensor # for testing pytrees class Foo(object): # noqa: B209 def __init__(self, a, b): self.a = a self.b = b class TestFX(JitTestCase): def setUp(self): # Checking for mutable operations whil tracing is feature flagged # Enable it in testing but not by default self.orig_tracer_mutable_flag = torch.fx.proxy.TracerBase.check_mutable_operations torch.fx.proxy.TracerBase.check_mutable_operations = True if not (TEST_WITH_ROCM or IS_FBCODE or IS_WINDOWS or IS_MACOS): lib_file_path = find_library_location('libtorchbind_test.so') torch.ops.load_library(str(lib_file_path)) def tearDown(self): torch.fx.proxy.TracerBase.check_mutable_operations = self.orig_tracer_mutable_flag def checkGraphModule(self, m: torch.nn.Module, args, kwargs=None): """Check that an nn.Module's results match the GraphModule version for a given set of args/kwargs. """ kwargs = kwargs if kwargs else {} ref_outs = m(*args, **kwargs) gm = symbolic_trace(m) gm.graph.lint() test_outs = gm(*args, **kwargs) self.assertEqual(ref_outs, test_outs) def test_graph_module(self): class MySub(torch.nn.Module): def __init__(self): super().__init__() self.w = torch.nn.Parameter(torch.rand(4, 3)) def forward(self, x): return self.w + x class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.lin = torch.nn.Linear(4, 3) self.sub_mod = MySub() self.w = torch.nn.Parameter(torch.rand(3)) def forward(self, A, B, c): t = torch.sigmoid(A) + self.lin(c) return self.sub_mod(t.data + self.w + t + 1 - A + B // A + -A + A.add(B, alpha=3)) m = MyModule() gm = symbolic_trace(m) ms = torch.jit.script(gm) class M2(torch.nn.Module): def forward(self, A): m, idx = torch.max(A, 0) return m + 1, idx + 1 m2 = M2() gm2 = symbolic_trace(m2) class T(torch.nn.Module): def forward(self, A, b=4, *args, c=5, **kwargs): x = A + 1 + args[0] + kwargs['3'] return x t = T() symbolic_trace(t) # test for issue described at https://github.com/pytorch/pytorch/issues/63883 class M3(torch.nn.Module): def forward(self, x): return torch.relu(x) m3 = M3() gm3 = symbolic_trace(m3) new_instance = gm3.__new__(type(gm3)) new_instance.__init__(gm3, gm3.graph) x = torch.randn(5, 3) torch.testing.assert_allclose(new_instance(x), torch.relu(x)) def test_custom_import(self): graph = torch.fx.Graph() a = graph.placeholder('x') b = graph.placeholder('y') c = graph.call_function(a_non_torch_leaf, (a, b)) d = graph.call_function(torch.sin, (c,)) graph.output(d) gm = GraphModule(torch.nn.Module(), graph) x, y = torch.rand(1), torch.rand(1) self.assertEqual(torch.sin(x + y), gm(x, y)) def test_args_kwargs(self): class T(torch.nn.Module): def forward(self, *args, **kwargs): x = args[0] + kwargs['foo'] return x t = T() self.checkGraphModule(t, (torch.rand(1), torch.rand(1)), {'foo': torch.rand(1)}) def test_args_kwargs_no_self(self): class T(torch.nn.Module): def forward(*args, **kwargs): # noqa: B902 self = args[0] return torch.relu(args[1]) t = T() with self.assertRaisesRegex(RuntimeError, r'cannot be part of \*args expansion'): self.checkGraphModule(t, (torch.rand(1), torch.rand(1)), {'foo': torch.rand(1)}) def test_fx_shifts(self): class MyModule(torch.nn.Module): def forward(self, x): return x << 3, x >> 3 input = torch.LongTensor(10).random_(0, 1024) m = MyModule() self.checkGraphModule(m, (input,)) def test_fx_and_or(self): class MyModule(torch.nn.Module): def forward(self, x): return x & x, x | x input = torch.LongTensor(10).random_(0, 1024) m = MyModule() self.checkGraphModule(m, (input,)) def test_dict(self): class MyDictMod(torch.nn.Module): def forward(self, d): return d['3'].relu(), {'4' : d['3'].neg()} input_dict = {'3': torch.rand(3, 4)} m = MyDictMod() self.checkGraphModule(m, (input_dict,)) def test_matmul_tracing(self): const = torch.randn(3) def matmul_f(x): return x @ const mod = symbolic_trace(matmul_f) inp = torch.randn(3) self.assertEqual(mod(inp), matmul_f(inp)) def rmatmul_f(x): return const @ x mod = symbolic_trace(rmatmul_f) inp = torch.randn(3) self.assertEqual(mod(inp), rmatmul_f(inp)) def test_disallow_override(self): # Custom delegate to disallow in-place tensor operations class NoMutableCallTracer(Tracer): def create_node(self, kind : str, target : Union[str, Callable], args : Tuple[Argument, ...], kwargs : Dict[str, Any], name : Optional[str] = None, type_expr : Optional[Any] = None) -> Node: name = target if isinstance(target, str) else torch.typename(target) if name[-1] == '_': raise RuntimeError('In-place operations are not supported') return super().create_node(kind, target, args, kwargs, name) # Test method class MyInplaceMod(torch.nn.Module): def forward(self, x): x.add_(3.0) return x m = MyInplaceMod() with self.assertRaisesRegex(RuntimeError, 'In-place operations'): NoMutableCallTracer().trace(m) # Test free function class MyInplaceMod2(torch.nn.Module): def forward(self, x): torch.log_(x) return x m2 = MyInplaceMod2() with self.assertRaisesRegex(RuntimeError, 'In-place operations'): NoMutableCallTracer().trace(m2) # Test symbolic node as an arg class MyInplaceMod3(torch.nn.Module): def forward(self, x): y = torch.ones(3, 4) y.add_(x) return x m3 = MyInplaceMod3() with self.assertRaisesRegex(RuntimeError, 'In-place operations'): NoMutableCallTracer().trace(m3) def test_leaf_module(self): # Custom delegate to make it so that there are no leaf modules, everything # should get traced through class NoLeafModulesTracer(Tracer): def is_leaf_module(self, m, qualname): return False class MyReluMod(torch.nn.Module): def __init__(self): super().__init__() self.relu = torch.nn.ReLU() def forward(self, x): return self.relu(x) mrm = MyReluMod() sym = NoLeafModulesTracer().trace(mrm) for node in sym.nodes: self.assertNotEqual(node.op, 'call_module') sym.lint() def test_wrap(self): self.assertEqual(3 + 4 + 5, a_lifted_leaf((3, 4), 5)) def to_trace(y): return a_lifted_leaf((4, y), 3) + a_lifted_leaf((3, 4), 5) + a_lifted_leaf((y, y), y) m = symbolic_trace(to_trace) self.assertIn('a_lifted_leaf', m.code) self.assertEqual(27, m(2)) self.assertIs(a_lifted_leaf, real_a_lifed_leaf) def test_wrap_fn_directly(self): self.assertEqual(3 + 4 + 5, a_lifted_leaf2((3, 4), 5)) def to_trace(y): return a_lifted_leaf2((4, y), 3) + a_lifted_leaf2((3, 4), 5) + a_lifted_leaf2((y, y), y) m = symbolic_trace(to_trace) self.assertIn('a_lifted_leaf2', m.code) self.assertEqual(27, m(2)) self.assertIs(a_lifted_leaf2, real_a_lifed_leaf2) def test_wrapped_via_decorator(self): self.assertEqual(wrapped_via_decorator(0), 1) def to_trace(y): return wrapped_via_decorator(y) m = symbolic_trace(to_trace) self.assertIn('wrapped_via_decorator', m.code) self.assertEqual(m(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) def test_wrapped_via_decorator_and_transformed(self): self.assertEqual(wrapped_via_decorator(0), 1) def to_trace(y): return wrapped_via_decorator(y) m = symbolic_trace(to_trace) self.assertIn('wrapped_via_decorator', m.code) self.assertEqual(m(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) transformed = torch.fx.Transformer(m).transform() self.assertIn('wrapped_via_decorator', transformed.code) self.assertEqual(transformed(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) def test_wrap_with_submodule(self): class M(torch.nn.Module): def __init__(self): super(M, self).__init__() self.batchnorm1d = torch.nn.BatchNorm1d(2, affine=False) def forward(self, x: torch.Tensor): return wrapped_with_submodule(x, self.batchnorm1d) m = symbolic_trace(M()) self.assertIn("wrapped_with_submodule", m.code) input = torch.rand(3, 2) ref_batchnorm1d = torch.nn.BatchNorm1d(2, affine=False) self.assertEqual(ref_batchnorm1d(input), m(input)) def test_wrapped_retrace(self): def to_trace(y): return wrapped_via_decorator(y) m = symbolic_trace(to_trace) self.assertIn('wrapped_via_decorator', m.code) self.assertEqual(m(0), 1) retraced = symbolic_trace(m) self.assertIn('wrapped_via_decorator', retraced.code) self.assertEqual(retraced(0), 1) def test_graph_edit_with_proxy(self): class M(torch.nn.Module): def forward(self, a, b): return a + b m = M() g = symbolic_trace(m).graph new_g = torch.fx.Graph() val_map : Dict[Node, Node] = {} output_val = new_g.graph_copy(g, val_map) t = Proxy(output_val) # test that we can use proxy objects to generate more graph code later for things that do not need to work with modules. new_g.output((t + t).node) gm = GraphModule(m, new_g) gm.graph.lint() self.assertEqual(gm(3, 4), 14) def test_graph_unique_names(self): class M(torch.nn.Module): def forward(self, a, b): return a + b m = M() g = symbolic_trace(m).graph new_g = torch.fx.Graph() val_map : Dict[Node, Node] = {} output_val = new_g.graph_copy(g, val_map) t = Proxy(output_val) # test that we can use proxy objects to generate more graph code later for things that do not need to work with modules. new_g.output((t + t).node) gm = GraphModule(m, new_g) seen_names : Set[str] = set() for node in gm.graph.nodes: assert node.name not in seen_names seen_names.add(node.name) def test_stack_traces(self): class M(torch.nn.Module): def forward(self, a, b): return a + b tracer = torch.fx.Tracer() tracer.record_stack_traces = True graph = tracer.trace(M()) # saving the original list because we will insert new nodes as a part of a test orig_graph_nodes = list(graph.nodes) for node in orig_graph_nodes: if node.op == 'output': continue self.assertTrue(node.stack_trace is not None) assert 'test_fx.py' in node.stack_trace # verify that copying the node does not lose the stack trace new_node = graph.node_copy(node) self.assertTrue(new_node.stack_trace is not None) assert 'test_fx.py' in new_node.stack_trace def test_graph_unique_names_manual(self): graph : torch.fx.Graph = torch.fx.Graph() a : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_module', 'linear_mod', args=(a,), name='foo_1_1') c : torch.fx.Node = graph.create_node('get_attr', 'y_attr', name='foo_1') d : torch.fx.Node = graph.create_node('call_function', operator.add, args=(b, c)) graph.output(d) graph2 = torch.fx.Graph() val_map : Dict[Node, Node] = {} graph2.graph_copy(graph, val_map) seen_names : Set[str] = set() for node in graph2.nodes: assert node.name not in seen_names seen_names.add(node.name) def test_unpack(self): class M(torch.nn.Module): def forward(self, a, b): c, d = a return c + d + b a = (torch.rand(1), torch.rand(1)) b = torch.rand(1) m = M() self.checkGraphModule(m, (a, b)) def test_native_callable(self): if TEST_WITH_ROCM or IS_FBCODE or IS_WINDOWS or IS_MACOS: raise unittest.SkipTest("non-portable load_library call used in test") # This test exercises the case where we use FX to translate from Python # code to some native callable object # # For the purposes of testing, we use ElementwiseInterpreter defined # in test_custom_class.cpp. # # We test that we can # 1) Construct a native callable from FX IR # 2) Construct a drop-in replacement module that delegates to the # native callable rather than the original code # 3) Run both the original code and native callable wrapper with # equivalent results # 4) TorchScript compile the native callable wrapper and confirm # equivalent results with the reference # 5) TorchScript serialize and deserialize the native callable # and confirm equivalent results with the reference # We use this simple Module as a reference computation class MySimpleMod(torch.nn.Module): def forward(self, x): return 3.0 * x + x msm = MySimpleMod() # This is what a lowering pass might look like: a function that takes # a valid nn.Module, symbolically traces it, lowers the Module to some # representation, and wraps that representation up into another # nn.Module instance that handles dispatch to the compiled/lowered code. def lower_to_elementwise_interpreter(orig_mod : torch.nn.Module) -> torch.nn.Module: # ===== Stage 1: Symbolic trace the module ===== mod = symbolic_trace(orig_mod) # ===== Stage 2: Lower GraphModule representation to the C++ # interpreter's instruction format ====== instructions = [] constant_idx = 0 constants = {} fn_input_names = [] target_to_name = { operator.add : "add", operator.mul : "mul" } output_node : Optional[Node] = None # For each instruction, create a triple # (instruction_name : str, inputs : List[str], output : str) # to feed into the C++ interpreter for n in mod.graph.nodes: target, args, out_name = n.target, n.args, n.name assert len(n.kwargs) == 0, "kwargs currently not supported" if n.op == 'placeholder': # Placeholders specify function argument names. Save these # for later when we generate the wrapper GraphModule fn_input_names.append(target) elif n.op == 'call_function': assert target in target_to_name, "Unsupported call target " + target arg_names = [] for arg in args: if not isinstance(arg, Node): # Pull out constants. These constants will later be # fed to the interpreter C++ object via add_constant() arg_name = f'constant_{constant_idx}' constants[arg_name] = torch.tensor( [arg] if isinstance(arg, numbers.Number) else arg) arg_names.append(arg_name) constant_idx += 1 else: arg_names.append(arg.name) instructions.append((target_to_name[target], arg_names, out_name)) elif n.op == 'output': if output_node is not None: raise RuntimeError('Multiple output nodes!') output_node = n else: raise RuntimeError('Unsupported opcode ' + n.op) interpreter = torch.classes._TorchScriptTesting._ElementwiseInterpreter() # Load constants for k, v in constants.items(): interpreter.add_constant(k, v) # Specify names for positional input arguments interpreter.set_input_names(fn_input_names) # Load instructions interpreter.set_instructions(instructions) # Specify name for single output assert isinstance(output_node.args[0], torch.fx.Node) interpreter.set_output_name(output_node.args[0].name) # ===== Stage 3: Create a wrapper GraphModule around the interpreter ===== class WrapperModule(torch.nn.Module): def __init__(self, interpreter): super().__init__() self.interpreter = interpreter wrapper = WrapperModule(interpreter) # Create a graph that: 1) Takes function arguments 2) Invokes the interpreter # 3) Returns the speficied return value # FIXME: The following code could be greatly simplified by symbolic_trace'ing # the wrapper with a Tracer that considers the Wrapper instance a root # module, however, I can't get `__call__` exposed on TorchBind classes # without it messing up Python `hasattr` for some reason. More digging # into CPython's implementation of hasattr is probably in order... graph = torch.fx.Graph() # Add placeholders for fn inputs placeholder_nodes = [] for name in fn_input_names: placeholder_nodes.append(graph.create_node('placeholder', name)) # Get the interpreter object interpreter_node = graph.create_node('get_attr', 'interpreter') # Add a node to call the interpreter instance output_node = graph.create_node( op='call_method', target='__call__', args=(interpreter_node, placeholder_nodes)) # Register output graph.output(output_node) graph.lint() # Return final GraphModule!!! return GraphModule(wrapper, graph) # Lower GraphModule to C++ interpreter lowered = lower_to_elementwise_interpreter(msm) # Compare correctness with original module x = torch.rand(3, 4) ref_out = msm(x) test_out = lowered(x) torch.testing.assert_close(test_out, ref_out) # Test TorchScript compilation scripted_lowered = torch.jit.script(lowered) script_out = scripted_lowered(x) torch.testing.assert_close(script_out, ref_out) # Test TorchScript ser/de import_copy = self.getExportImportCopy(scripted_lowered) imported_out = import_copy(x) torch.testing.assert_close(imported_out, ref_out) def test_reserved_getattr(self): """Ensure that we do not name any nodes with a reserved builtin like `getattr`""" class M(torch.nn.Module): def forward(self, a): return a.foo.bar.baz m = M() m_g = symbolic_trace(m) m_g.graph.lint() for node in m_g.graph.nodes: self.assertTrue(node.name != "getattr") def test_node_tagging(self): class TaggingTracer(Tracer): def create_node(self, kind : str, target : Union[str, Callable], args : Tuple[Argument, ...], kwargs : Dict[str, Any], name : Optional[str] = None, type_expr : Optional[Any] = None) -> Node: n = super().create_node(kind, target, args, kwargs, name) n.tag = 'foo' return n class M(torch.nn.Module): def forward(self, a, b): return a + b m = M() g = TaggingTracer().trace(m) g.lint() for n in g.nodes: self.assertTrue(hasattr(n, 'tag')) self.assertEqual(n.tag, 'foo') def test_tensor_attribute(self): class TensorAttribute(torch.nn.Module): def __init__(self): super().__init__() self.tensor = torch.rand(3, 4) def forward(self, x): return torch.nn.functional.linear(x, self.tensor) ta = TensorAttribute() traced = symbolic_trace(ta) traced(torch.rand(4, 4)) class WrapperForQualname(torch.nn.Module): def __init__(self): super().__init__() self.ta = TensorAttribute() def forward(self, x): return torch.nn.functional.linear(x, self.ta.tensor) wfq = WrapperForQualname() traced2 = symbolic_trace(wfq) traced2.graph.lint() traced2(torch.rand(4, 4)) def test_tensor_attribute_coalseced(self): def count_attrs(fx_module): targets = set() for node in traced.graph.nodes: if node.op == 'get_attr': targets.add(node.target) return len(targets) val = torch.tensor(5) def f(x): return x + val + val traced = symbolic_trace(f) traced.graph.lint() self.assertEqual(count_attrs(traced), 1) val2 = torch.tensor(5) def f(x): val = torch.tensor(5) return x + val + val2 traced = symbolic_trace(f) traced.graph.lint() self.assertEqual(count_attrs(traced), 2) def test_symbolic_trace_sequential(self): class Simple(torch.nn.Module): def forward(self, x): return torch.neg(x) seq = torch.nn.Sequential( Simple(), Simple(), Simple() ) traced = symbolic_trace(seq) traced.graph.lint() x = torch.rand(3, 4) self.assertEqual(traced(x), seq(x)) def test_tensor_constant(self): class ConstTensor(torch.nn.Module): def forward(self, x): return torch.nn.functional.linear(x, torch.zeros(3, 4)) ct = ConstTensor() traced = symbolic_trace(ct) traced.graph.lint() traced(torch.rand(4, 4)) def test_pickle_graphmodule(self): class Nested(torch.nn.Module): def __init__(self): super().__init__() self.st = torch.nn.Linear(4, 4) def forward(self, x): return self.st(x) n = Nested() traced = symbolic_trace(n) traced.graph.lint() pickled = pickle.dumps(traced) loaded = pickle.loads(pickled) loaded.graph.lint() x = torch.rand(3, 4) self.assertEqual(loaded(x), traced(x)) def test_pickle_custom_import(self): graph = torch.fx.Graph() a = graph.placeholder('x') b = graph.placeholder('y') c = graph.call_function(a_non_torch_leaf, (a, b)) d = graph.call_function(torch.sin, (c,)) graph.output(d) gm = GraphModule(torch.nn.Module(), graph) pickled = pickle.dumps(gm) loaded = pickle.loads(pickled) loaded.graph.lint() x, y = torch.rand(1), torch.rand(1) self.assertEqual(loaded(x, y), gm(x, y)) def test_all_input_nodes(self): graph : torch.fx.Graph = torch.fx.Graph() a : torch.fx.Node = graph.placeholder('x') b : torch.fx.Node = graph.call_module('linear_mod', args=(a,)) c : torch.fx.Node = graph.get_attr('y_attr') d : torch.fx.Node = graph.call_function(operator.add, args=(b, c)) e : torch.fx.Node = graph.call_function(torch.unsqueeze, args=(d, 0)) graph.output(e) graph.lint() self.assertEqual(b.all_input_nodes, [a]) self.assertEqual(c.all_input_nodes, []) self.assertEqual(d.all_input_nodes, [b, c]) self.assertEqual(e.all_input_nodes, [d]) def test_deepcopy_graphmodule_with_transform(self): st = SimpleTest() traced = symbolic_trace(st) traced.graph.lint() def transform(traced): new_graph = torch.fx.Graph() val_map : Dict[Node, Node] = {} output_value = new_graph.graph_copy(traced.graph, val_map) relu_out = new_graph.create_node( op='call_method', target='neg', args=(output_value,), kwargs={}) new_graph.output(relu_out) return GraphModule(traced, new_graph) transformed = transform(traced) transformed.graph.lint() copied = copy.deepcopy(transformed) self.assertNotEqual(id(type(transformed)), id(type(copied))) x = torch.randn(3, 4) self.assertEqual(copied(x), transformed(x)) def test_deepcopy_with_submods_params(self): class Bar(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) def forward(self, x): return torch.relu(x) + self.param class Baz(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.bar = Bar() def forward(self, x): return self.bar(x) - self.param baz = Baz() traced = symbolic_trace(baz) traced.graph.lint() copied = copy.deepcopy(traced) copied.graph.lint() def test_deepcopy_graph_with_tracer_cls(self): class TestTracer(Tracer): def is_leaf_module(self, module, name): return True g = Graph(tracer_cls=TestTracer) x = g.placeholder("x") g.output(x) h = copy.deepcopy(g) self.assertIsNotNone(h._tracer_cls) self.assertTrue(g._tracer_cls == h._tracer_cls) def test_unpack_list_better_error(self): class SomeArgs(torch.nn.Module): def forward(self, a, b): return torch.rand(3, 4) class UnpacksList(torch.nn.Module): def __init__(self): super().__init__() self.sa = SomeArgs() def forward(self, x : list): return self.sa(*x) ul = UnpacksList() with self.assertRaisesRegex(TraceError, 'Proxy object cannot be iterated.'): symbolic_trace(ul) def test_unpack_dict_better_error(self): class SomeKwargs(torch.nn.Module): def forward(self, x=3, y=4): return torch.rand(3, 4) class UnpacksDict(torch.nn.Module): def __init__(self): super().__init__() self.sk = SomeKwargs() def forward(self, x : dict): return self.sk(**x) ud = UnpacksDict() with self.assertRaisesRegex(TraceError, 'Proxy object cannot be iterated.'): symbolic_trace(ud) def test_pretty_print_targets(self): # Test that Graph pretty-print prints friendly name for targets # in `operator` and `builtins` class SomeMod(torch.nn.Module): def forward(self, x): return torch.add(x.foo + x.bar, 3.0) traced = symbolic_trace(SomeMod()) graph_str = str(traced.graph) self.assertIn('builtins.getattr', graph_str) self.assertIn('operator.add', graph_str) self.assertIn('torch.add', graph_str) def test_pretty_print_node(self): class M(torch.nn.Module): def __init__(self): super().__init__() self.param: torch.nn.Parameter = torch.nn.Parameter( torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x: torch.Tensor, y: int = 2): return self.linear(x[y] + self.param).clamp(min=0.0, max=1.0) traced = symbolic_trace(M()) all_formatted = "\n".join([n.format_node() for n in traced.graph.nodes]) FileCheck().check("x").check("placeholder") \ .check("y").check("placeholder") \ .check("getitem").check("call_function") \ .check("param").check("get_attr") \ .check("add").check("call_function") \ .check("linear").check("call_module") \ .check("clamp").check("call_method") \ .run(all_formatted) def test_script_tensor_constant(self): # TorchScript seems to ignore attributes that start with `__`. # We used to call anonymous Tensor values `__tensor_constant*`, but # they were getting ignored by script. Now they're called # `_tensor_constant*` class IHaveATensorConstant(torch.nn.Module): def forward(self, x): return x + torch.rand(3, 4) traced = torch.fx.symbolic_trace(IHaveATensorConstant()) torch.jit.script(traced) def test_autowrap_functions(self): class AutowrapFnTest(torch.nn.Module): def forward(self, x): return fx_int(x.shape[0] / 2) class AutowrapFnTest2(torch.nn.Module): def forward(self, x): return fx_int(x.shape[0] / 2) + fx_int_x2(x.shape[0] / 2) # Check function(s) are wrapped # `int` would normally throw a TypeError as argument can't be `Proxy` tracer = Tracer(autowrap_functions=(fx_int,)) graph = tracer.trace(AutowrapFnTest()) traced = GraphModule(tracer.root, graph, 'test') tracer_2 = Tracer(autowrap_functions=(fx_int, fx_int_x2)) tracer_2.trace(AutowrapFnTest2()) # Test scriptability traced_scripted = torch.jit.script(traced) self.assertEqual(traced_scripted(torch.rand(4)), 2) def test_torch_fx_len(self): class FXLenTest(torch.nn.Module): def forward(self, x): return len(x) traced = symbolic_trace(FXLenTest()) self.assertEqual(traced(torch.rand(3, 4)), 3) # Test scriptability scripted = torch.jit.script(FXLenTest()) self.assertEqual(scripted(torch.rand(3)), 3) traced_scripted = torch.jit.script(traced) self.assertEqual(traced_scripted(torch.rand(3)), 3) # Test non-proxy len class FXLenTest2(torch.nn.Module): def __init__(self): super().__init__() self.l = [3, 4, 5] def forward(self, x): return x + len(self.l) traced2 = symbolic_trace(FXLenTest2()) inp = torch.rand(3, 4) self.assertEqual(traced2(inp), inp + 3.0) self.assertIs(len, builtins.len) def test_torch_fx_getattr(self): class FXGetattrTest(torch.nn.Module): def forward(self, x): return getattr(x, 'nonexistent_attr', torch.Tensor([2, 3])) traced = symbolic_trace(FXGetattrTest()) self.assertEqual(traced(torch.rand(3, 4)), torch.Tensor([2, 3])) def test_sqrt(self): class Sqrt1(torch.nn.Module): def forward(self, x): return sqrt(x.size(0)) class Sqrt2(torch.nn.Module): def forward(self, x): return math.sqrt(x.size(0)) class Sqrt3(torch.nn.Module): def forward(self, x): return x + math.sqrt(2) + sqrt(2) self.checkGraphModule(Sqrt1(), [torch.zeros(8)]) self.checkGraphModule(Sqrt2(), [torch.zeros(8)]) self.checkGraphModule(Sqrt3(), [torch.zeros(8)]) self.assertIs(sqrt, _sqrt) self.assertIs(math.sqrt, _sqrt) def test_torch_custom_ops(self): class M(torch.nn.Module): def forward(self, a): b = torch.ops.aten.sigmoid(a) c = torch.ops.aten.cat([a, b]) return torch.ops.aten.cat((c, c)) m = M() input = torch.randn(3) ref_out = m(input) gm = symbolic_trace(m) gm.graph.lint() out = gm(input) self.assertEqual(out, ref_out) def test_pickle_torch_custom_ops(self): class M(torch.nn.Module): def forward(self, a): b = torch.ops.aten.sigmoid(a) c = torch.ops.aten.cat([a, b]) return torch.ops.aten.cat((c, c)) m = M() input = torch.randn(3) ref_out = m(input) gm = symbolic_trace(m) gm.graph.lint() pickled = pickle.dumps(gm) loaded = pickle.loads(pickled) self.assertEqual(loaded(input), gm(input)) def test_pretty_print(self): st = SimpleTest() traced = symbolic_trace(st) traced.graph.lint() printed = str(traced) assert 'SimpleTest()' in printed assert 'torch.relu' in printed def test_pretty_print_graph(self): class KwargPrintTest(torch.nn.Module): def forward(self, x): return torch.squeeze(x + 3.0, dim=2) st = KwargPrintTest() traced = symbolic_trace(st) traced.graph.lint() stringed = str(traced.graph) for s in ['args', 'kwargs', '#users']: assert s in stringed def test_custom_proxy_type(self): class TensorPair: def __init__(self, left, right): self.left, self.right = left, right def add(self, other): l = self.left + other.left r = self.right + other.right return TensorPair(l, r) def mul(self, other): l = self.left * other.left r = self.right * other.right return TensorPair(l, r) def use_tensor_pair(x : TensorPair, y : TensorPair): s = x.add(y) return s.mul(x) x = TensorPair(torch.randn(5, 3), torch.randn(5, 3)) y = TensorPair(torch.randn(5, 3), torch.randn(5, 3)) ref_out = use_tensor_pair(x, y) traced = symbolic_trace(use_tensor_pair) traced_out = traced(x, y) self.assertEqual(traced_out.left, ref_out.left) self.assertEqual(traced_out.right, ref_out.right) def test_custom_proxy_type_literal(self): class TensorPair(metaclass=torch.fx.ProxyableClassMeta): def __init__(self, left, right): self.left, self.right = left, right def add(self, other): l = self.left + other.left r = self.right + other.right return TensorPair(l, r) def mul(self, other): l = self.left * other.left r = self.right * other.right return TensorPair(l, r) def use_tensor_pair_literal(x : TensorPair): s = x.add(TensorPair(torch.zeros(5, 3), torch.zeros(5, 3))) return s.mul(x) x = TensorPair(torch.randn(5, 3), torch.randn(5, 3)) ref_out = use_tensor_pair_literal(x) traced = symbolic_trace(use_tensor_pair_literal) traced_out = traced(x) self.assertEqual(traced_out.left, ref_out.left) self.assertEqual(traced_out.right, ref_out.right) def test_custom_proxy_dynamic_value(self): class TensorPair(metaclass=torch.fx.ProxyableClassMeta): def __init__(self, left, right): self.left, self.right = left, right def add(self, other): l = self.left + other.left r = self.right + other.right return TensorPair(l, r) def mul(self, other): l = self.left * other.left r = self.right * other.right return TensorPair(l, r) def use_tensor_pair_ctor(x : TensorPair, y : torch.Tensor): s = x.add(TensorPair(y, y)) return s.mul(x) x = TensorPair(torch.randn(5, 3), torch.randn(5, 3)) y = torch.randn(5, 3) ref_out = use_tensor_pair_ctor(x, y) traced = symbolic_trace(use_tensor_pair_ctor) traced_out = traced(x, y) self.assertEqual(traced_out.left, ref_out.left) self.assertEqual(traced_out.right, ref_out.right) def test_custom_proxy_input_dependent_control_flow(self): class ZeroTensor(metaclass=torch.fx.ProxyableClassMeta): def __init__(self, inp): if inp.sum() == 0: self.is_zero = True self.tensor = torch.tensor([]) else: self.is_zero = False self.tensor = inp def add(self, other): if self.is_zero: return ZeroTensor(other.tensor) elif other.is_zero: return self def use_zero_tensor(x : torch.Tensor, y : torch.Tensor): return ZeroTensor(x + y) x, y = torch.randn(5, 3), torch.randn(5, 3) ref_out = use_zero_tensor(x, y) traced = symbolic_trace(use_zero_tensor) traced_out = traced(x, y) self.assertEqual(traced_out.is_zero, ref_out.is_zero) self.assertEqual(traced_out.tensor, ref_out.tensor) def test_graph_fns(self): g = Graph() a = g.placeholder('a') b = g.call_module('linear', (a,)) c = g.get_attr('bias') d = g.call_method('add', (b, c)) e = g.call_function(torch.sin, (d,)) g.output(e) mod = torch.nn.Module() mod.linear = torch.nn.Linear(3, 4) mod.bias = torch.rand(4) gm = GraphModule(mod, g) gm.graph.lint() input = torch.rand(3) r = gm(input) ref = torch.sin(mod.linear(input) + mod.bias) self.assertEqual(r, ref) def test_remove_uses(self): g : torch.fx.Graph = Graph() x : torch.fx.Node = g.placeholder('x') relu : torch.fx.Node = g.call_function(torch.relu, (x,)) neg : torch.fx.Node = g.call_function(torch.neg, (relu,)) g.output(neg) neg.replace_all_uses_with(relu) g.erase_node(neg) self.assertTrue(neg not in relu.users) def test_nonetype_annotation(self): eb = torch.nn.EmbeddingBag(3, 4) symbolic_trace(eb) def test_pickle_nonetype_annotation(self): eb = torch.nn.EmbeddingBag(10, 3, mode='sum') traced = symbolic_trace(eb) pickled = pickle.dumps(traced) loaded = pickle.loads(pickled) loaded.graph.lint() input = torch.LongTensor([1, 2, 4, 5, 4, 3, 2, 9]) offsets = torch.LongTensor([0, 4]) self.assertEqual(loaded(input, offsets), traced(input, offsets)) def test_return_tuple(self): class M(torch.nn.Module): def forward(self, x: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: return (x, x + x) original = M() traced = symbolic_trace(original) self.assertEqual(traced(torch.ones(1)), original.forward(torch.ones(1))) def test_construct_root_dict(self): graph : torch.fx.Graph = torch.fx.Graph() a : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_module', 'foo.bar.baz', args=(a,)) c : torch.fx.Node = graph.create_node('get_attr', 'zip.zap.zam') d : torch.fx.Node = graph.create_node('call_function', operator.add, args=(b, c)) graph.output(d) linear_mod : torch.nn.Module = torch.nn.Linear(3, 4) add_param : torch.Tensor = torch.rand(3, 4) gm : torch.fx.GraphModule = torch.fx.GraphModule( {'foo.bar.baz': linear_mod, 'zip.zap.zam' : add_param}, graph) gm.graph.lint() assert 'self.foo.bar.baz' in gm.code x : torch.Tensor = torch.rand(3, 3) out : torch.Tensor = gm(x) ref_out : torch.Tensor = linear_mod(x) + add_param self.assertEqual(out, ref_out) def test_symbolic_trace_assert(self): class AssertsTensorShape(torch.nn.Module): def forward(self, x): torch._assert(x.shape[1] > 4, "assert_foobar") return x m = AssertsTensorShape() # verify traceability traced = symbolic_trace(m) # verify assertion on traced model works correctly at runtime traced(torch.rand(4, 5)) with self.assertRaisesRegex(AssertionError, "assert_foobar"): traced(torch.rand(4, 3)) # verify the symbolically traced module is scriptable ms = torch.jit.script(m) with self.assertRaisesRegex(torch.jit.Error, "assert_foobar"): ms(torch.rand(4, 3)) def test_fx_create_arg(self): class CustomArgObject: def __init__(self, x, y): self.x = x self.y = y def __fx_create_arg__(self, tracer: torch.fx.Tracer): return tracer.create_node( "call_function", CustomArgObject, args=( tracer.create_arg(self.x), tracer.create_arg(self.y), ), kwargs={}, ) class HasCustomArgObjectWhenLeaf(torch.nn.Module): def forward(self, o: CustomArgObject): # Not normally traceable; good reason to make # this module a leaf. for x in o.x: o.y += x return o.y class Root(torch.nn.Module): def __init__(self): super().__init__() self.inner = HasCustomArgObjectWhenLeaf() def forward(self, x, y): o = CustomArgObject(x, y) return self.inner(o) class CreateArgTracer(torch.fx.Tracer): def is_leaf_module(self, m, module_qualified_name): return type(m) is HasCustomArgObjectWhenLeaf m = Root() graph = CreateArgTracer().trace(m) gm = torch.fx.GraphModule(m, graph) assert "CustomArgObject(" in gm.code def test_trace_fn_constant(self): some_constant = torch.rand(3, 4) def add_const(x): return some_constant + x traced = symbolic_trace(add_const) input = torch.rand(3, 4) self.assertEqual(traced(input), add_const(input)) def test_copy_no_remap(self): traced = symbolic_trace(SimpleTest()) g = traced.graph copied = torch.fx.Graph() for node in g.nodes: copied.node_copy(node) with self.assertRaisesRegex(RuntimeError, 'does not belong to this Graph'): copied.lint() def test_wrong_topo(self): graph : torch.fx.Graph = torch.fx.Graph() a : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_module', 'foo.bar.baz', args=(a,)) c : torch.fx.Node = graph.create_node('get_attr', 'zip.zap.zam') d : torch.fx.Node = graph.create_node('call_function', operator.add, args=(b, c)) graph.output(d) nodes = list(graph.nodes) nodes[3].append(nodes[2]) with self.assertRaisesRegex(RuntimeError, 'was used before it has been defined'): graph.lint() def test_wrong_target_type(self): graph : torch.fx.Graph = torch.fx.Graph() with self.assertRaises(ValueError): n = torch.fx.Node(graph=graph, name='foo', op='call_function', target='foo', args=(), kwargs={}) def test_example_shape_prop(self): class TestCase(torch.nn.Module): def __init__(self): super().__init__() self.attr = torch.randn(3, 4) self.submod = torch.nn.Linear(4, 4) def forward(self, x): return torch.neg(self.submod(x.relu() + self.attr)) tc = TestCase() tc_traced = symbolic_trace(tc) ref_out = tc_traced(torch.rand(3, 4)) shape_prop.ShapeProp(tc_traced).propagate(torch.rand(3, 4)) # Make sure we're testing all opcodes opcodes = set() output_shape : Optional[torch.Shape] = None output_stride : Optional[Tuple[int]] = None for node in tc_traced.graph.nodes: opcodes.add(node.op) if node.op == 'output': output_shape = node.args[0].meta['tensor_meta'].shape output_stride = node.args[0].meta['tensor_meta'].stride self.assertEqual(opcodes, set(['placeholder', 'get_attr', 'call_function', 'call_method', 'call_module', 'output'])) # Test shape propogation and make sure results match actual self.assertEqual(output_shape, ref_out.shape) self.assertEqual(output_stride, ref_out.stride()) def test_shape_prop_layout(self): class ConvTest(torch.nn.Module): def __init__(self): super().__init__() self.conv_mod = torch.nn.Conv2d(5, 5, 3) def forward(self, x): return self.conv_mod(x) # contiguous layout test_mod = ConvTest() traced = symbolic_trace(test_mod) x = torch.randn(5, 5, 224, 224) shape_prop.ShapeProp(traced).propagate(x) assert(all(node.meta['tensor_meta'].memory_format is torch.contiguous_format for node in traced.graph.nodes)) x_channels_last = x.contiguous(memory_format=torch.channels_last) traced.to(memory_format=torch.channels_last) shape_prop.ShapeProp(traced).propagate(x_channels_last) for node in traced.graph.nodes: # NB: the implementation of conv may not preserve the memory format, # unfortunately. The best we can do is just check that the placeholder # node is channels-last if node.op in {'placeholder'}: self.assertEqual(node.meta['tensor_meta'].memory_format, torch.channels_last) def test_shape_prop_aggregate(self): class ReturnTwo(torch.nn.Module): def forward(self, x): return (3, torch.sum(x)) class UnderTest(torch.nn.Module): def __init__(self): super().__init__() self.rt = ReturnTwo() def forward(self, x): return self.rt(x) ut = UnderTest() class RTTracer(torch.fx.Tracer): def is_leaf_module(self, m, module_qualified_name): return type(m) is ReturnTwo graph = RTTracer().trace(ut) mod = torch.fx.GraphModule(ut, graph) shape_prop.ShapeProp(mod).propagate(torch.rand(3, 4)) for node in mod.graph.nodes: if node.op == 'call_module': assert 'tensor_meta' in node.meta tensor_meta = node.meta['tensor_meta'] assert tensor_meta[0] == 3 assert tensor_meta[1].shape == torch.Size([]) def test_shape_prop_layout_3d(self): class ConvTest3d(torch.nn.Module): def __init__(self): super().__init__() self.conv_mod = torch.nn.Conv3d(5, 5, 3) def forward(self, x): return self.conv_mod(x) test_mod_3d = ConvTest3d() traced_3d = symbolic_trace(test_mod_3d) x_3d = torch.randn(5, 5, 224, 224, 15) shape_prop.ShapeProp(traced_3d).propagate(x_3d) assert(all(node.meta['tensor_meta'].memory_format is torch.contiguous_format for node in traced_3d.graph.nodes)) x_channels_last_3d = x_3d.contiguous(memory_format=torch.channels_last_3d) traced_3d.to(memory_format=torch.channels_last_3d) shape_prop.ShapeProp(traced_3d).propagate(x_channels_last_3d) for node in traced_3d.graph.nodes: # NB: the implementation of conv may not preserve the memory format, # unfortunately. The best we can do is just check that the placeholder # node is channels-last if node.op in {'placeholder'}: self.assertEqual(node.meta['tensor_meta'].memory_format, torch.channels_last_3d) def test_interpreter(self): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): return self.linear(x + self.param).clamp(min=0.0, max=1.0) m = MyModule() gm = torch.fx.symbolic_trace(m) interpreter = Interpreter(gm) input = torch.randn(3, 4) self.assertEqual(interpreter.run(input), gm(input)) self.assertEqual(interpreter.run(input), m(input)) def test_interpreter_run_node_override(self): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): return self.linear(x + self.param).clamp(min=0.0, max=1.0) m = MyModule() gm = torch.fx.symbolic_trace(m) class RunNodeInterpreter(Interpreter): def __init__(self, module): super().__init__(module) def run_node(self, n : Node) -> Any: result = super().run_node(n) n.cached_value = result return result input = torch.randn(3, 4) RunNodeInterpreter(gm).run(input) for node in gm.graph.nodes: assert hasattr(node, 'cached_value') def test_interpreter_onthefly_swap(self): def fn(x): return torch.sigmoid(x).neg() gm = torch.fx.symbolic_trace(fn) class NegSigmSwapInterpreter(Interpreter): def call_function(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == torch.sigmoid: return torch.neg(*args, **kwargs) return super().call_function(n) def call_method(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == 'neg': call_self, *args_tail = args return call_self.sigmoid(*args_tail, **kwargs) return super().call_method(n) input = torch.randn(3, 4) result = NegSigmSwapInterpreter(gm).run(input) self.assertEqual(result, torch.neg(input).sigmoid()) def test_interpreter_partial_eval(self): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): return self.linear(x + self.param).clamp(min=0.0, max=1.0) gm = torch.fx.symbolic_trace(MyModule()) interp = Interpreter(gm) env = {} for node in gm.graph.nodes: if node.op == 'call_module' and node.target == 'linear': env[node] = torch.arange(0, 12, 1).reshape(3, 4) - 6.0 break assert len(env) == 1 x = torch.randn(3, 4) result = interp.run(x, initial_env=env) self.assertEqual(result, (torch.arange(0, 12, 1).reshape(3, 4) - 6.0).clamp(0.0, 1.0)) def test_interpreter_star_args(self): def with_star_args(x, *args): return x + args[0] gm = torch.fx.symbolic_trace(with_star_args) interp = Interpreter(gm) result = interp.run(torch.ones(3, 4), torch.ones(3, 4), torch.rand(3, 4)) self.assertEqual(result, torch.ones(3, 4) * 2.0) @skipIfNoTorchVision def test_interpreter_noop_resnet18(self): rn18 = torchvision_models.resnet18() transformed = torch.fx.Transformer(symbolic_trace(rn18)).transform() inp = torch.randn(5, 3, 224, 224) self.assertEqual(transformed(inp), rn18(inp)) @skipIfNoTorchVision def test_interpreter_gc_values(self): rn18 = torchvision_models.resnet18() interp = Interpreter(symbolic_trace(rn18)) inp = torch.rand(5, 3, 224, 224) out = interp.run(inp) env_key_names = set(n.name for n in interp.env.keys()) self.assertEqual(env_key_names, set(['output'])) def test_interpreter_default_args(self): class Model(torch.nn.Module): def forward(self, x, y=3.14159): return x + y model = Model() gm = torch.fx.symbolic_trace(model) interp = Interpreter(gm) x = torch.randn(5, 3) out = interp.run(x) torch.testing.assert_allclose(out, x + 3.14159) def test_interpreter_not_enough_args(self): class Model(torch.nn.Module): def forward(self, x, y): return x + y model = Model() gm = torch.fx.symbolic_trace(model) interp = Interpreter(gm) x = torch.randn(5, 3) with self.assertRaisesRegex(RuntimeError, 'Expected positional argument for parameter y, but one was not passed in'): out = interp.run(x) def test_transformer_noop(self): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): return self.linear(x + self.param).clamp(min=0.0, max=1.0) m = MyModule() gm = torch.fx.symbolic_trace(m) new_gm = Transformer(gm).transform() input = torch.randn(3, 4) self.assertEqual(new_gm(input), gm(input)) def test_transformer_op_swap(self): def fn(x): return torch.sigmoid(x).neg() gm = torch.fx.symbolic_trace(fn) class NegSigmSwapXformer(Transformer): def call_function(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == torch.sigmoid: return torch.neg(*args, **kwargs) return super().call_function(n) def call_method(self, target : Target, args : Tuple, kwargs : Dict) -> Any: if target == 'neg': call_self, *args_tail = args return call_self.sigmoid(*args_tail, **kwargs) return super().call_method(n) transformed = NegSigmSwapXformer(gm).transform() input = torch.randn(3, 4) self.assertEqual(transformed(input), torch.neg(input).sigmoid()) def test_transformer_multi_outputs(self): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.param = torch.nn.Parameter(torch.rand(3, 4)) self.linear = torch.nn.Linear(4, 5) def forward(self, x): x = x + self.param out = self.linear(x) return x, out m = MyModule() gm = torch.fx.symbolic_trace(m) new_gm = Transformer(gm).transform() input = torch.randn(3, 4) self.assertEqual(new_gm(input), gm(input)) def test_fn_type_annotations(self): class Foo(torch.nn.Module): def forward(self, p : Pair, z : torch.Tensor, i : int) -> Dict[str, torch.Tensor]: return {'a': p.x + p.y + z + i} foo_scripted = torch.jit.script(Foo()) foo_scripted(Pair(torch.rand(5), torch.rand(5)), torch.rand(5), 3) fxed = symbolic_trace(Foo()) fxed_scripted = torch.jit.script(fxed) fxed_scripted(Pair(torch.rand(5), torch.rand(5)), torch.rand(5), 3) def test_fn_type_annotation_empty(self): def forward(a : List[torch.Tensor]): return a[0] torch.jit.script(symbolic_trace(forward)) def test_wrapped_method(self): def wrap_with_relu(fn): @functools.wraps(fn) def wrapper(*args, **kwargs): return torch.relu(fn(*args, **kwargs)) return wrapper class Foo(torch.nn.Module): @wrap_with_relu def forward(self, x, w): return torch.matmul(x, w) f = Foo() traced = symbolic_trace(f) x, w = torch.rand(3, 4), torch.rand(4, 4) self.assertTrue(any(n.target == torch.relu for n in traced.graph.nodes)) def test_empty_graph_codegen(self): graph = torch.fx.Graph() gm = torch.fx.GraphModule(torch.nn.Module(), graph) self.assertEqual(gm(), None) def test_sequential(self): m = torch.nn.Sequential(torch.nn.Conv2d(1, 1, 1)) gm = torch.fx.symbolic_trace(m) gm_copy = copy.deepcopy(gm) def test_ctx_mgr(self): @contextlib.contextmanager def do_nothing(): yield class M(torch.nn.Module): def __init__(self): super().__init__() @do_nothing() def forward(self, x): return torch.relu(x) m = M() self.checkGraphModule(m, (torch.rand(3, 4),)) def test_typename_print(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,), type_expr=List[float]) output : torch.fx.Node = graph.output(b) self.assertTrue('typing.List[float]' in str(graph)) def test_layout(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, x): return torch.empty_like(x, layout=torch.strided, pin_memory=False).fill_(0) traced = symbolic_trace(M()) x = torch.rand(5, 9, 3, 4) self.assertEqual(traced(x), torch.zeros_like(x)) def test_ellipsis(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, x, y): return x + y[:, 1:10, ...] traced = symbolic_trace(M()) x, y = torch.rand(5, 9, 3, 4), torch.rand(5, 15, 3, 4) self.assertEqual(traced(x, y), x + y[:, 1:10, ...]) def test_inf_nan(self): class FooMod(torch.nn.Module): def forward(self, x): return x + float('inf'), x + float('-inf'), x + float('nan') fm = FooMod() self.checkGraphModule(fm, (torch.rand(3, 4),)) def test_inf_nan_kwds(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_function', operator.add, (x, float('inf')), {}, name='inf') c : torch.fx.Node = graph.create_node('call_function', operator.add, (x, float('nan')), {}, name='nan') graph.output((b, c)) gm = torch.fx.GraphModule(torch.nn.Module(), graph) x = torch.rand(3, 4) self.assertEqual(gm(x), (x + float('inf'), x + float('nan'))) def test_deepcopy_recursion_depth(self): depth = sys.getrecursionlimit() + 20 g = torch.fx.Graph() x = g.placeholder('x') for i in range(depth): x = g.call_function(torch.relu, (x,)) g.output(x) copied_graph = copy.deepcopy(g) val_map = {} for orig_node, new_node in zip(g.nodes, copied_graph.nodes): val_map[orig_node] = new_node for orig_node, new_node in zip(g.nodes, copied_graph.nodes): orig_users = set(orig_node.users.keys()) orig_users_equiv = set(val_map[u] for u in orig_users) new_users = set(new_node.users.keys()) self.assertEqual(orig_users_equiv, new_users) @skipIfNoTorchVision def test_replace_uses(self): rn18 = torchvision_models.resnet18() class LowerReluTracer(torch.fx.Tracer): def is_leaf_module(self, m : torch.nn.Module, qualname : str): if isinstance(m, torch.nn.ReLU): return False return super().is_leaf_module(m, qualname) rn18_traced = GraphModule(rn18, LowerReluTracer().trace(rn18)) to_erase = [] for node in rn18_traced.graph.nodes: if node.op == 'call_function' and node.target in [torch.relu, torch.nn.functional.relu]: kwargs = node.kwargs.copy() # Neg doesn't have in-place kwargs.pop('inplace') with rn18_traced.graph.inserting_before(node): new_node = rn18_traced.graph.call_function( the_function=torch.neg, args=node.args, kwargs=node.kwargs) node.replace_all_uses_with(replace_with=new_node) to_erase.append(node) for node in to_erase: rn18_traced.graph.erase_node(node) def test_replace_input(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') y : torch.fx.Node = graph.create_node('placeholder', 'y') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,)) output : torch.fx.Node = graph.output(b) b.replace_input_with(x, y) gm = torch.fx.GraphModule(torch.nn.Module(), graph) input_x = torch.randn(33, 44) input_y = torch.randn(11, 22) self.assertEqual(gm(input_x, input_y), torch.relu(input_y)) def test_insertion_point(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,)) output : torch.fx.Node = graph.output(b) with graph.inserting_before(b): neg : torch.fx.Node = graph.call_function(the_function=torch.neg, args=(x,)) _, *relu_args = b.args b.args = (neg, *relu_args) gm = torch.fx.GraphModule(torch.nn.Module(), graph) input = torch.randn(33, 44) self.assertEqual(gm(input), torch.relu(torch.neg(input))) def test_update_args_api(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') y : torch.fx.Node = graph.create_node('placeholder', 'y') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,)) output : torch.fx.Node = graph.output(b) orig_gm = torch.fx.GraphModule(torch.nn.Module(), graph) inp_x, inp_y = torch.randn(5, 3), torch.randn(3, 5) self.assertEqual(orig_gm(inp_x, inp_y), torch.relu(inp_x)) b.update_arg(0, y) new_gm = torch.fx.GraphModule(torch.nn.Module(), graph) self.assertEqual(new_gm(inp_x, inp_y), torch.relu(inp_y)) def test_update_kwargs_api(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') y : torch.fx.Node = graph.create_node('placeholder', 'y') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, kwargs={'input': x}) output : torch.fx.Node = graph.output(b) orig_gm = torch.fx.GraphModule(torch.nn.Module(), graph) inp_x, inp_y = torch.randn(5, 3), torch.randn(3, 5) self.assertEqual(orig_gm(inp_x, inp_y), torch.relu(inp_x)) b.update_kwarg('input', y) new_gm = torch.fx.GraphModule(torch.nn.Module(), graph) self.assertEqual(new_gm(inp_x, inp_y), torch.relu(inp_y)) def test_move_before(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,)) output : torch.fx.Node = graph.output(b) neg : torch.fx.Node = graph.call_function(the_function=torch.neg, args=(x,)) _, *relu_args = b.args b.args = (neg, *relu_args) b.prepend(neg) gm = torch.fx.GraphModule(torch.nn.Module(), graph) input = torch.randn(33, 44) self.assertEqual(gm(input), torch.relu(torch.neg(input))) def test_prepend_self(self): graph : torch.fx.Graph = torch.fx.Graph() x : torch.fx.Node = graph.create_node('placeholder', 'x') b : torch.fx.Node = graph.create_node('call_function', target=torch.relu, args=(x,)) output : torch.fx.Node = graph.output(b) b.prepend(b) x.append(b) self.assertEqual(len(graph.nodes), 3) def test_erase_node_error(self): st = SimpleTest() traced = symbolic_trace(st) for node in traced.graph.nodes: # Test deleting with uses both in another Node and at the output if node.target in [operator.add, torch.relu]: with self.assertRaisesRegex(RuntimeError, 'but it still had .* users in the graph'): traced.graph.erase_node(node) def test_copy_it(self): d = immutable_dict([(3, 4), (5, 6)]) l = immutable_list([(3, 4), (5, 6)]) self.assertEqual(d, deepcopy(d)) self.assertEqual(l, deepcopy(l)) def test_get_torch_func_signature(self): for key in dir(torch): obj = getattr(torch, key) if callable(obj): schemas = get_signature_for_torch_op(obj) def test_find_uses(self): graph = torch.fx.Graph() x = torch.fx.Proxy(graph.placeholder('x')) y = torch.relu(x) z = x + x u = torch.neg(x) graph.output((y + z + u).node) graph.lint() users_of_x = x.node.users self.assertEqual(len(users_of_x), 3) expected_ops = set(['relu', 'add', 'neg']) for use in users_of_x: assert any(use.name.startswith(prefix) for prefix in expected_ops) def test_inline_graph(self): class InlineInto(torch.nn.Module): def forward(self, x): return torch.relu(x) class ToInline(torch.nn.Module): def forward(self, x): return torch.neg(x) inline_into = symbolic_trace(InlineInto()) to_inline = symbolic_trace(ToInline()) combined_graph = torch.fx.Graph() output_node = combined_graph.graph_copy(inline_into.graph, {}) input_node = list(to_inline.graph.nodes)[0] assert input_node and input_node.op == 'placeholder' val_map = {input_node : output_node} output = combined_graph.graph_copy(to_inline.graph, val_map) combined_graph.output(output) combined_module = torch.fx.GraphModule(torch.nn.Module(), combined_graph) input = torch.rand(3, 4) self.assertEqual(combined_module(input), input.relu().neg()) def test_multi_insert_point(self): graph = torch.fx.Graph() x = torch.fx.Proxy(graph.placeholder('x')) relu = torch.relu(x) with graph.inserting_before(relu.node): y = torch.neg(x) z = torch.tanh(y) graph.output((relu.node, z.node)) graph.lint() expected_ops = ['x', 'neg', 'tanh', 'relu'] for node, expected in zip(graph.nodes, expected_ops): assert expected in node.name def test_reassign_args_kwargs_uses(self): graph = torch.fx.Graph() x, y = Proxy(graph.placeholder('x')), Proxy(graph.placeholder('y')) z = x + y zed = z + z + z graph.output(zed.node) graph.lint() # zed = z + z + z -> zed = z + z + x zed.node.args = (zed.node.args[0], x.node) self.assertEqual(list(x.node.users.keys()), [z.node, zed.node]) # z = x + y -> z = y + y z.node.args = (y.node, y.node) self.assertEqual(list(x.node.users.keys()), [zed.node]) def test_trace_function(self): def foo(x, y): return torch.relu(x) + y x, y = torch.randn(3, 4), torch.randn(3, 4) self.checkGraphModule(foo, (x, y)) def test_trace_dict_int_keys(self): class ModWithDictArg(torch.nn.Module): def forward(self, d : Dict[int, torch.Tensor]): return d[42] class CallsModWithDict(torch.nn.Module): def __init__(self): super().__init__() self.m = ModWithDictArg() def forward(self, x): return self.m({42: x}) class MyTracer(torch.fx.Tracer): def is_leaf_module(self, m: torch.nn.Module, module_qualified_name : str) -> bool: return isinstance(m, ModWithDictArg) traced_graph = MyTracer().trace(CallsModWithDict()) def test_trace_dict_proxy_keys(self): class ModWithDictArg(torch.nn.Module): def forward(self, d : Dict[torch.Tensor, torch.Tensor]): return d[42] class CallsModWithDict(torch.nn.Module): def __init__(self): super().__init__() self.m = ModWithDictArg() def forward(self, x): return self.m({x: x}) class MyTracer(torch.fx.Tracer): def is_leaf_module(self, m: torch.nn.Module, module_qualified_name : str) -> bool: return isinstance(m, ModWithDictArg) with self.assertRaisesRegex(RuntimeError, 'cannot contain a Node'): traced_graph = MyTracer().trace(CallsModWithDict())
def test_module_deepcopy_edit_nodes(self): class Foo(torch.nn.Module): def forward(self, x): return torch.relu(x) traced1 = symbolic_trace(Foo()) copied = copy.deepcopy(traced1) for node in copied.graph.nodes: if node.target == torch.relu: node.target = torch.neg copied.recompile() traced1.recompile() x = torch.randn(15, 15) torch.testing.assert_allclose(traced1(x), torch.relu(x)) torch.testing.assert_allclose(copied(x), torch.neg(x)) def test_direct_param_use(self): class TransposeTest(torch.nn.Module): def __init__(self): super().__init__() self.b = torch.nn.Parameter(torch.rand(4, 3)) def forward(self, x): return self.b class Foo(torch.nn.Module): def __init__(self): super().__init__() self.a = TransposeTest() def forward(self, x): return self.a.b, self.a.b.t(), self.a.b.view(12) traced = torch.fx.symbolic_trace(Foo()) assert(all('constant' not in node.target for node in traced.graph.nodes)) def test_single_default_arg(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, y=1): return y m = M() self.checkGraphModule(m, ()) self.checkGraphModule(m, (3,)) def test_multiple_default_args(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, y=1, z=2): return y + z m = M() self.checkGraphModule(m, ()) self.checkGraphModule(m, (3,)) self.checkGraphModule(m, (3, 4)) def test_regular_and_default_args(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, x, y=1): return x + y m = M() self.checkGraphModule(m, (2,)) self.checkGraphModule(m, (2, 3)) def test_string_literal_return(self): class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self): return "foo" m = M() self.checkGraphModule(m, ()) def test_namedtuple_return_qualname(self): class NamedTupReturn(torch.nn.Module): def forward(self, x): return MyNamedTup(x, x) traced = symbolic_trace(NamedTupReturn()) input = torch.rand(3, 4) self.assertEqual(traced(input), MyNamedTup(input, input)) def test_update_args_kwargs_yells_at_you(self): symtraced = symbolic_trace(SimpleTest()) node = next(iter(symtraced.graph.nodes)) with self.assertRaisesRegex(AttributeError, '__update_args_kwargs'): node.__update_args_kwargs((), {}) def test_torchbind_class_attribute_in_fx(self): if TEST_WITH_ROCM or IS_FBCODE or IS_WINDOWS or IS_MACOS: self.skipTest("torch.classes._TorchScriptTesting._StackString is registered, skipping") class FooBar1234(torch.nn.Module): def __init__(self): super(FooBar1234, self).__init__() self.f = torch.classes._TorchScriptTesting._StackString(["3", "4"]) def forward(self): return self.f.top() m = FooBar1234() self.checkGraphModule(m, ()) def test_torchbind_class_attribute_in_fx_tensor_arg(self): if TEST_WITH_ROCM or IS_FBCODE or IS_WINDOWS or IS_MACOS: self.skipTest("torch.classes._TorchScriptTesting._ReLUClass is registered, skipping") class FooBar2341(torch.nn.Module): def __init__(self): super(FooBar2341, self).__init__() self.f = torch.classes._TorchScriptTesting._ReLUClass() def forward(self, x): return self.f.run(x) m = FooBar2341() traced = symbolic_trace(m) input = torch.randn(3, 4) self.assertEqual(traced(input), m(input)) self.assertTrue(any(n.op == 'call_method' for n in traced.graph.nodes)) def test_script_method_trace(self): class Scripted(torch.nn.Module): def forward(self, x): return torch.relu(x) class Holder(torch.nn.Module): def __init__(self): super().__init__() self.s = torch.jit.script(Scripted()) def forward(self, x): return self.s(x) h = Holder() traced = symbolic_trace(h) input = torch.randn(3, 4) self.assertEqual(traced(input), h(input)) self.assertTrue(any(n.op == 'call_method' for n in traced.graph.nodes)) def test_namedtuple_return_trace(self): class NamedTupReturn(torch.nn.Module): def forward(self, x): return Pair(x, x) traced = symbolic_trace(NamedTupReturn()) input = torch.rand(3, 4) self.assertEqual(traced(input), Pair(input, input)) def test_return_type_exists(self): class ReturnTypeModule(torch.nn.Module): def other(self, x: List[str]) -> List[str]: return x def forward(self, x: List[str]) -> List[str]: return self.other(x) traced = symbolic_trace(ReturnTypeModule()) self.assertIn("-> typing_List[str]", traced._code) scripted = torch.jit.script(traced) self.assertIn("-> List[str]", scripted.code) def getitem_inner(self): class GetItemBase(torch.nn.Module): def __init__(self): super().__init__() self.register_buffer('pe', torch.randn(8, 8)) class GetItem1(GetItemBase): def forward(self, x): return self.pe[:, :x.size(0)] class GetItem2(GetItemBase): def forward(self, x): return self.pe[x.size(0)] class GetItem3(GetItemBase): def forward(self, x): return self.pe[4] # fx creates `self._tensor_constant0` here self.checkGraphModule(GetItem1(), [torch.zeros(4)]) self.checkGraphModule(GetItem2(), [torch.zeros(4)]) self.checkGraphModule(GetItem3(), [torch.zeros(4)]) @unittest.skipUnless(os.environ.get("FX_PATCH_GETITEM") == "1", "Will be checked in test_getitem_subproc") def test_getitem(self): self.getitem_inner() def test_getitem_subproc(self): # need to run this test in a subproc to work around: # https://github.com/pytorch/pytorch/issues/50710 proc = Process(target=run_getitem_target) proc.start() proc.join() self.assertEqual(proc.exitcode, 0) def test_user_friendly_call_provenance_with_function(self): def fn(x): return wrapper_fn(x) traced = torch.fx.symbolic_trace(fn) with self.assertRaisesRegex(RuntimeError, "'wrapper_fn' is " "being compiled since it was called" " from 'fn.forward'"): scripted = torch.jit.script(traced) def test_user_friendly_call_provenance_with_module(self): class M(torch.nn.Module): def forward(self, x): return wrapper_fn(x) traced = torch.fx.symbolic_trace(M()) with self.assertRaisesRegex(RuntimeError, "'wrapper_fn' is " "being compiled since it was called" " from 'M.forward'"): scripted = torch.jit.script(traced) def test_snake_case(self): class M(torch.nn.Module): def __init__(self): super(M, self).__init__() self.activations = torch.nn.ModuleDict([ ["snake_case", torch.nn.ReLU()], ["PascalCase", torch.nn.LeakyReLU()], ["ALL_CAPS", torch.nn.PReLU()] ]) def forward(self, x): a = self.activations["snake_case"](x) b = self.activations["PascalCase"](x) c = self.activations["ALL_CAPS"](x) return a, b, c traced = symbolic_trace(M()) check = [ ("activations_snake_case", "activations.snake_case"), ("activations_pascal_case", "activations.PascalCase"), ("activations_all_caps", "activations.ALL_CAPS") ] i = 0 for node in traced.graph.nodes: if node.op == "placeholder" or node.op == "output": continue name = check[i][0] target = check[i][1] self.assertEqual(name, node.name) self.assertEqual(target, node.target) i += 1 self.assertEqual(i, 3) def test_no_mutation(self): from torch.fx.immutable_collections import immutable_list x = immutable_list([3, 4]) with self.assertRaisesRegex(NotImplementedError, "new_args"): x[0] = 4 def test_partial_trace(self): class Foo(torch.nn.Module): def forward(self, x, y): if y: return 2 * x else: return x mod = Foo() mod_true = symbolic_trace(mod, concrete_args={'y': True}) mod_false = symbolic_trace(mod, concrete_args={'y': False}) self.assertEqual(mod_true(3, True), 6) print(mod_true.code) assert(any([i.target == torch._assert for i in mod_true.graph.nodes])) with self.assertRaises(AssertionError): mod_true(3, False) self.assertEqual(mod_false(3, False), 3) with self.assertRaises(AssertionError): mod_false(3, True) def f_higher(a, f): return f(a) nf = symbolic_trace(f_higher, concrete_args={'f': lambda x: x * 2}) self.assertEqual(nf(3, lambda x: x * 2), 6) def test_custom_traceback_raised_when_exception_source_is_graphmodule(self): class M(torch.nn.Module): def __init__(self): super(M, self).__init__() self.W = torch.nn.Parameter(torch.randn(5)) def forward(self, x): return torch.dot(self.W, x) traced = torch.fx.symbolic_trace(M()) out = [n for n in traced.graph.nodes if n.op == "output"][-1] with traced.graph.inserting_before(out): relu_out = traced.graph.call_method(method_name='relu', args=(out.args[0],)) out.args = (relu_out,) traced.recompile() with self.capture_stderr() as captured: with self.assertRaises(TypeError): traced(5) self.assertRegex(captured[0], r"Call using an FX-traced Module, line .* of the " r"traced Module's generated forward function:") def test_custom_traceback_not_raised_when_exception_source_is_submodule(self): class M(torch.nn.Module): def __init__(self): super().__init__() self.linear = torch.nn.Linear(3, 4) def forward(self, x): return self.linear(x) traced = torch.fx.symbolic_trace(M()) # Do not change this to `capture_stderr` or another context # manager without ensuring that the output is as expected try: traced(torch.rand(5, 5)) except RuntimeError: captured = traceback.format_exc() self.assertNotRegex(captured, r"Call using an FX-traced Module, line .* of the " r"traced Module's generated forward function:") def test_graph_module_replicate_for_dp(self): class Foo(torch.nn.Module): def forward(self, x): return torch.relu(x) gm = torch.fx.symbolic_trace(Foo()) x = torch.randn(5, 3) out = gm(x) replica = gm._replicate_for_data_parallel() out_replica = replica(x) torch.testing.assert_allclose(out_replica, out) def test_ast_rewriter_rewrites_assert(self): class M(torch.nn.Module): def forward(self, x: torch.Tensor, y: int, z: int): assert y == z return torch.add(x, x) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(M()) traced = GraphModule(ast_rewriter.root, graph, "gm") traced.graph.lint() def test_ast_rewriter_rewrites_assert_with_message(self): class M(torch.nn.Module): def forward(self, x: torch.Tensor, y: int, z: int): assert y == z, "msg" return torch.add(x, x) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(M()) traced = GraphModule(ast_rewriter.root, graph, "gm") traced.graph.lint() def test_throw_out_variant(self): def foo(x): y = torch.rand_like(x) torch.sigmoid(x, out=y) return y class MyTracer(torch.fx.Tracer): check_mutable_operations = True tracer = MyTracer() with self.assertRaisesRegex(RuntimeError, 'mutable operation aten::sigmoid.out'): traced_graph = tracer.trace(foo) def test_ast_rewriter_reassigns_submodules(self): class M(torch.nn.Module): def __init__(self): super().__init__() self.bn = torch.nn.BatchNorm2d(100) def forward(self, x: torch.Tensor): return torch.add(x, x) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(M()) traced = GraphModule(ast_rewriter.root, graph, "gm") traced.graph.lint() def test_ast_rewriter_wrap(self): self.assertEqual(3 + 4 + 5, a_lifted_leaf((3, 4), 5)) def to_trace(y): return ( a_lifted_leaf((4, y), 3) + a_lifted_leaf((3, 4), 5) + a_lifted_leaf((y, y), y) ) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(to_trace) traced = GraphModule(ast_rewriter.root, graph, "gm") self.assertIn("a_lifted_leaf", traced.code) self.assertEqual(27, traced(2)) self.assertIs(a_lifted_leaf, real_a_lifed_leaf) def test_ast_rewriter_wrap_fn_directly(self): self.assertEqual(3 + 4 + 5, a_lifted_leaf2((3, 4), 5)) def to_trace(y): return ( a_lifted_leaf2((4, y), 3) + a_lifted_leaf2((3, 4), 5) + a_lifted_leaf2((y, y), y) ) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(to_trace) traced = GraphModule(ast_rewriter.root, graph, "gm") self.assertIn("a_lifted_leaf2", traced.code) self.assertEqual(27, traced(2)) self.assertIs(a_lifted_leaf2, real_a_lifed_leaf2) def test_profiler_ranges_side_effect(self): g = torch.fx.Graph() handle = g.call_function(torch.ops.profiler._record_function_enter, ('test_range',)) g.call_function(torch.ops.profiler._record_function_exit, (handle,)) g.output(None) found_targets = {} for node in g.nodes: if node.op == 'call_function': found_targets.setdefault(node.target) self.assertEqual( list(found_targets.keys()), [torch.ops.profiler._record_function_enter, torch.ops.profiler._record_function_exit] ) g.eliminate_dead_code() found_targets = {} for node in g.nodes: if node.op == 'call_function': found_targets.setdefault(node.target) self.assertEqual( list(found_targets.keys()), [torch.ops.profiler._record_function_enter, torch.ops.profiler._record_function_exit] ) def test_ast_rewriter_wrapped_via_decorator(self): class F(torch.nn.Module): def forward(self, x): return wrapped_via_decorator(x) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(F()) traced = GraphModule(ast_rewriter.root, graph, "gm") self.assertIn("wrapped_via_decorator", traced.code) self.assertEqual(traced(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) def test_ast_rewriter_wrapped_via_decorator_and_transformed(self): self.assertEqual(wrapped_via_decorator(0), 1) def to_trace(y): return wrapped_via_decorator(y) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(to_trace) traced = GraphModule(ast_rewriter.root, graph, "gm") self.assertIn("wrapped_via_decorator", traced.code) self.assertEqual(traced(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) transformed = torch.fx.Transformer(traced).transform() self.assertIn("wrapped_via_decorator", transformed.code) self.assertEqual(transformed(0), 1) self.assertIs(wrapped_via_decorator, real_wrapped_via_decorator) self.assertFalse(hasattr(wrapped_via_decorator, "__fx_already_patched")) def test_ast_rewriter_wrap_with_submodule(self): class M(torch.nn.Module): def __init__(self): super(M, self).__init__() self.batchnorm1d = torch.nn.BatchNorm1d(2, affine=False) def forward(self, x: torch.Tensor): return wrapped_with_submodule(x, self.batchnorm1d) ast_rewriter = RewritingTracer() graph = ast_rewriter.trace(M()) traced = GraphModule(ast_rewriter.root, graph, "gm") self.assertIn("wrapped_with_submodule", traced.code) input = torch.rand(3, 2) ref_batchnorm1d = torch.nn.BatchNorm1d(2, affine=False) self.assertEqual(ref_batchnorm1d(input), traced(input)) def test_submodule_manipulation_API(self): class C(torch.nn.Module): def __init__(self): super(C, self).__init__() self.conv = torch.nn.Conv2d(16, 33, 3, stride=2) self.param = torch.nn.Parameter(torch.rand(2, 3)) def forward(self, x): return self.conv(torch.cat([self.param, x])) class B(torch.nn.Module): def __init__(self): super(B, self).__init__() self.linear = torch.nn.Linear(100, 200) self.register_buffer("buf", torch.randn(2, 3)) self.net_c = C() def forward(self, x): return self.linear(torch.cat([self.buf, self.net_c(x)])) class A(torch.nn.Module): def __init__(self): super(A, self).__init__() self.net_b = B() self.param = torch.nn.Parameter(torch.rand(2, 3)) def forward(self, x): return self.net_b(x) + self.param a = symbolic_trace(A()) a.add_submodule("net_b.net_c.dropout", torch.nn.Dropout(p=0.2)) conv = [n for n in a.graph.nodes if n.target == "net_b.net_c.conv"][-1] with a.graph.inserting_before(conv): with warnings.catch_warnings(record=True) as w: dropout = a.graph.call_module(module_name="net_b.net_c.dropout", args=conv.args) self.assertEqual(len(w), 0) conv.replace_all_uses_with(dropout) a.graph.erase_node(conv) a.recompile() def module_exists(gm: GraphModule, path: str) -> bool: return any(path == name for name, _ in gm.named_modules()) def parameter_exists(gm: GraphModule, path: str) -> bool: return (any(path == name for name, _ in gm.named_parameters()) and any(path == name for name in gm.state_dict().keys())) def buffer_exists(gm: GraphModule, path: str) -> bool: return (any(path == name for name, _ in gm.named_buffers()) and any(path == name for name in gm.state_dict().keys())) # Test that we added the "dropout" submodule self.assertTrue(module_exists(a, "net_b.net_c.dropout")) # Test `get_submodule` with an added submodule self.assertIsNotNone(a.get_submodule("net_b.net_c.dropout")) # Test that the "conv" submodule is still there self.assertTrue(module_exists(a, "net_b.net_c.conv")) # Test `get_submodule` with an original module self.assertIsNotNone(a.get_submodule("net_b.net_c.conv")) # Test that the "conv" node is NOT still there conv = [n for n in a.graph.nodes if n.target == "net_b.net_c.conv"] self.assertEqual(conv, []) a.delete_submodule("net_b.net_c.conv") # Test that the "conv" submodule is now gone self.assertFalse(module_exists(a, "net_b.net_c.conv")) # Test `get_submodule` with a deleted submodule with self.assertRaisesRegex(AttributeError, "has no attribute " "`conv`"): self.assertIsNone(a.get_submodule("net_b.net_c.conv")) # Test `get_attr` warnings cat = [n for n in a.graph.nodes if n.target == torch.cat][-1] with a.graph.inserting_before(cat): with warnings.catch_warnings(record=True) as w: param = a.graph.get_attr(qualified_name="net_b.net_c.param") self.assertEqual(len(w), 0) with self.assertWarnsRegex(UserWarning, "Attempted to " "insert a get_attr Node with no " "underlying reference in the " "owning GraphModule"): bad_param = a.graph.get_attr(qualified_name="net_b.param") a.graph.erase_node(bad_param) cat.args = (*cat.args, param) a.recompile() a.graph.lint() # Test `get_parameter` a.get_parameter("net_b.net_c.param") with self.assertRaisesRegex(AttributeError, "is not an " "nn.Parameter"): a.get_parameter("net_b.buf") with self.assertRaisesRegex(AttributeError, "has no attribute " "`param`"): a.get_parameter("net_b.param") # Test `get_buffer` a.get_buffer("net_b.buf") with self.assertRaisesRegex(AttributeError, "is not a " "buffer"): a.get_buffer("net_b.net_c.param") with self.assertRaisesRegex(AttributeError, "has no attribute " "`buf`"): a.get_buffer("net_b.net_c.buf") # Test non-nested attributes a.get_submodule("") a.get_parameter("param") # Insert some unused submodules a.add_submodule("net_b.embedding", torch.nn.Embedding(10, 3)) a.add_submodule("net_b.net_c.embedding", torch.nn.Embedding(10, 3)) a.add_submodule("net_b.net_c.rnn", torch.nn.RNN(10, 20, 2)) a.add_submodule("batch_norm_2d", torch.nn.BatchNorm2d(100)) # Garbage collection a.delete_all_unused_submodules() # Test that all the unused submodules are gone self.assertFalse(module_exists(a, "net_b.embedding")) self.assertFalse(module_exists(a, "net_b.net_c.embedding")) self.assertFalse(module_exists(a, "net_b.net_c.rnn")) self.assertFalse(module_exists(a, "batch_norm_2d")) # Test that we didn't delete any unused Parameters or buffers self.assertTrue(parameter_exists(a, "net_b.net_c.param")) self.assertTrue(buffer_exists(a, "net_b.buf")) a.graph.lint() def test_delete_unused_submodules_leaf(self): class SubModule(torch.nn.Module): def __init__(self): super().__init__() self.linear = torch.nn.Linear(10, 10) self.relu = torch.nn.ReLU() def forward(self, x): x = self.linear(x) x = self.relu(x) return x class Model(torch.nn.Module): def __init__(self): super().__init__() self.submod = SubModule() def forward(self, x): x = self.submod(x) return x model = Model() class MyCustomTracer(torch.fx.Tracer): def is_leaf_module(self, m: torch.nn.Module, module_qualified_name : str) -> bool: return module_qualified_name == "submod" inputs = torch.randn(1, 10) traced_graph = MyCustomTracer().trace(model) gm2 = torch.fx.GraphModule(model, traced_graph) gm2.delete_all_unused_submodules() torch.testing.assert_allclose(gm2(inputs), model(inputs)) def test_tracing_graphmodules_as_leaf_submodules(self): class A(torch.nn.Module): def forward(self, t): return t + t class B(torch.nn.Module): def __init__(self): super(type(self), self).__init__() self.calling = False self.called = False def forward(self, t): if self.calling: return t - t else: return t + t def __call__(self, *args): self.called = True self.calling = True return super(type(self), self).__call__(*args) self.calling = False class M(torch.nn.Module): def __init__(self, a, b): super().__init__() self.a = a self.b = b def forward(self, t): x = self.a(t) y = self.b(t) return x + y class LeafTracer(Tracer): def is_leaf_module(self, module, name): return True class LeafTracerNotB(Tracer): def is_leaf_module(self, module, name): return False if "b" in name else True # Recompile calls added "for fun", since they # chain __call__ wrappers. # # Test: B as a regular, non-leaf module # a = symbolic_trace(A()) a.recompile() m = M(a, B()) graph = LeafTracerNotB().trace(m) gm = GraphModule(m, graph) gm.recompile() # Test graphmodule/submodule a is not inlined. self.assertTrue(isinstance(gm.get_submodule("a"), GraphModule)) match = [n for n in gm.graph.nodes if n.op == "call_module" and n.target == "a"] self.assertTrue(len(match) == 1) # Test submodule b is not treated as leaf. self.assertFalse(hasattr(gm, "b")) # Test assert custom __call__ on submodule b was honored. match = [ n for n in gm.graph.nodes if n.op == "call_function" and n.target == operator.sub ] self.assertTrue(len(match) == 1) # # Test: B as a regular, leaf module # symbolic_trace should only patch torch.nn.Module.__call__, # which means B.__call__ should still execute # a = symbolic_trace(A()) a.recompile() b = B() m = M(a, b) graph = LeafTracer().trace(m) gm = GraphModule(m, graph) gm.recompile() # Test graphmodule/submodule a is not inlined. self.assertTrue(isinstance(gm.get_submodule("a"), GraphModule)) match = [n for n in gm.graph.nodes if n.op == "call_module" and n.target == "a"] self.assertTrue(len(match) == 1) # Test submodule b is leaf: self.assertTrue(isinstance(gm.get_submodule("b"), torch.nn.Module)) match = [n for n in gm.graph.nodes if n.op == "call_module" and n.target == "b"] self.assertTrue(len(match) == 1) # Test b.__call__ was run self.assertTrue(b.called) self.assertTrue(gm.get_submodule("b").called) # # Test: B as GraphModule leaf # __call__ not honored since symbolic_trace directly invokes forward() # a = symbolic_trace(A()) a.recompile() b = symbolic_trace(B()) b.recompile() m = M(a, b) graph = LeafTracer().trace(m) gm = GraphModule(m, graph) gm.recompile() self.assertTrue(isinstance(gm.get_submodule("a"), GraphModule)) match = [n for n in gm.graph.nodes if n.op == "call_module" and n.target == "a"] self.assertTrue(len(match) == 1) self.assertTrue(isinstance(gm.get_submodule("b"), torch.nn.Module)) match = [n for n in gm.graph.nodes if n.op == "call_module" and n.target == "b"] self.assertTrue(len(match) == 1) def _test_graph_module_init_buffer_param_copied(self, use_dict_init: bool): class MyModule(torch.nn.Module): def __init__(self): super().__init__() self.register_buffer("my_buff", torch.rand(3, 4)) self.register_parameter( "my_param", torch.nn.Parameter(torch.rand(3, 4)) ) def forward(self, x): return x + self.my_buff + self.my_param mod = MyModule() mod_traced = symbolic_trace(mod) # Create new GraphModule based on original, either w/ dict or root module. orig_buff = mod_traced.get_buffer("my_buff") orig_param = mod_traced.get_parameter("my_param") mod_traced_new = GraphModule( {"my_buff": orig_buff, "my_param": orig_param} if use_dict_init else mod, mod_traced.graph, ) # Check that both my_buff and my_param are found and the same. try: new_buff = mod_traced_new.get_buffer("my_buff") except Exception: self.fail("Did not find my_buff") self.assertEqual(orig_buff, new_buff) try: new_param = mod_traced_new.get_parameter("my_param") except Exception: self.fail("Did not find my_param") self.assertEqual(orig_param, new_param) x = torch.rand(3, 4) orig_out = mod_traced(x) submodules_out = mod_traced_new(x) self.assertEqual(orig_out, submodules_out) def test_graph_module_init_buffer_param_copied_dict_init(self): self._test_graph_module_init_buffer_param_copied(use_dict_init=True) def test_graph_module_init_buffer_param_copied_mod_init(self): self._test_graph_module_init_buffer_param_copied(use_dict_init=False) def test_annotations_with_no_forward_references(self): class A: def __call__(self, x: torch.Tensor): return torch.add(x, x) class M(torch.nn.Module): def forward(self, x: torch.Tensor, a: A) -> torch.Tensor: return a(x) self.checkGraphModule(M(), (torch.rand(2, 3), A()), kwargs=None) def test_annotations_with_forward_references(self): class A: def __call__(self, x: torch.Tensor): return torch.add(x, x) class M(torch.nn.Module): def forward(self, x: 'torch.Tensor', a: 'A') -> 'torch.Tensor': return a(x) self.checkGraphModule(M(), (torch.rand(2, 3), A()), kwargs=None) def test_annotations_with_non_torch_reference_and_no_internal_forward_references(self): class A: def __call__(self, x: torch.Tensor): return torch.add(x, x) class M(torch.nn.Module): def forward(self, x: List[torch.Tensor], a: A) -> torch.Tensor: return a(x[0]) self.checkGraphModule(M(), (torch.rand(2, 3), A()), kwargs=None) def test_annotations_with_non_torch_reference_and_internal_forward_references(self): class A: def __call__(self, x: torch.Tensor): return torch.add(x, x) class M(torch.nn.Module): def forward(self, x: List['torch.Tensor'], a: A) -> 'torch.Tensor': return a(x)[0] self.checkGraphModule(M(), (torch.rand(2, 3), A()), kwargs=None) @unittest.skipIf(sys.version_info < (3, 7), "`__future__` feature " "`annotations` is not defined in Python <3.7") def test_annotation_with_future(self): try: import fx.test_future # noqa: F401 finally: del sys.modules["__future__"] def test_annotations_empty_tuple(self): class Foo(torch.nn.Module): def forward(self, x: Tuple[()], y: Tuple[str, Tuple[()]]): return "foo" traced = torch.fx.symbolic_trace(Foo()) x = () y = ("bar", ()) traced(x, y) FileCheck().check("_Tuple[()]") \ .check("typing_Tuple[str,typing_Tuple[()]]") \ .run(traced.code) scripted = torch.jit.script(traced) scripted(x, y) FileCheck().check("Tuple[()]") \ .check("Tuple[str, Tuple[()]]") \ .run(scripted.code) @unittest.skipIf(IS_WINDOWS, "Python Windows bug? https://bugs.python.org/issue45108") def test_assert(self): def f(x): assert x > 1 return x + 1 try: torch.fx.proxy.TracerBase.trace_asserts = True traced = symbolic_trace(f) finally: torch.fx.proxy.TracerBase.trace_asserts = False self.assertEqual(f(2), traced(2)) with self.assertRaises(AssertionError): traced(0) def test_pytree(self): def f_sum(x): return sum(x) def f_sum_dict(x): out = 0 for k, v in x.items(): out += v return out def f_dict_list_map(x): new_dict = {} for k, v in x.items(): new_dict[k] = [i + 1 for i in v] return new_dict def f_dict_add(x): return x['a'] + sum(x['z']) def f_namedtuple_add(x): return x.x + x.y pytree._register_pytree_node( Foo, lambda x: ([x.a, x.b], None), lambda x, _: Foo(x[0], x[1]), ) fx_pytree.register_pytree_flatten_spec(Foo, lambda x, _: [x.a, x.b]) def f_custom(x): return x.a + x.b def f_custom_dict(x): return f_sum_dict(x.a) + x.b def f_return_custom(x): return Foo(x.b, x.a) tests = [ (f_sum, [PH, PH, PH]), (f_sum, []), (f_sum_dict, {'a': PH, 'b': PH, 'c': PH}), (f_dict_list_map, {'a': (PH, PH), 'b': [PH], 'c': []}), (f_dict_list_map, {5: (PH, PH, PH)}), (f_dict_add, {'a': PH, 'z': (PH, PH, PH)}), (f_dict_add, {'a': PH, 'z': []}), (f_custom, Foo(PH, PH)), (f_custom, Foo(PH, 3)), (f_custom_dict, Foo({'a': PH, 'b': PH}, PH)), # (f_return_custom, Foo(PH, PH)), # Don't currently support output pytrees (f_namedtuple_add, Point(PH, PH)), ] def verify_pytree(f, inp): val = pytree.tree_map(lambda x: torch.randn(3) if x == PH else x, inp) num_flat_args = len([i == PH for i in pytree.tree_flatten(inp)[0]]) orig_out = f(val) nf = symbolic_trace(f, concrete_args={'x': inp}) self.assertEqual(nf(val), orig_out) bare_fx = GraphModule({}, copy.deepcopy(nf.graph)) bare_fx.graph.set_codegen(CodeGen()) bare_fx.recompile() self.assertEqual(nf.graph.process_outputs(bare_fx(*nf.graph.process_inputs(val))), orig_out) assert num_flat_args == 0 or "tree_flatten_spec" in nf.code assert(sum([i.op == 'placeholder' for i in nf.graph.nodes]) == num_flat_args) nf = symbolic_trace(nf) self.assertEqual(nf(val), orig_out) assert "tree_flatten_spec" not in nf.code assert(sum([i.op == 'placeholder' for i in nf.graph.nodes]) == 1) nf = symbolic_trace(nf, concrete_args={'x': inp}) self.assertEqual(nf(val), orig_out) assert num_flat_args == 0 or "tree_flatten_spec" in nf.code assert(sum([i.op == 'placeholder' for i in nf.graph.nodes]) == num_flat_args) pickled = pickle.dumps(nf) nf = pickle.loads(pickled) self.assertEqual(nf(val), orig_out) for f, inp in tests: verify_pytree(f, inp) def test_pytree_concrete(self): def f(b, a): if b: return a['a'] else: return a['z'] inp = {'a': {'a': PH, 'z': PH}, 'b': True} nf = symbolic_trace(f, concrete_args=inp) val = pytree.tree_map(lambda x: torch.randn(3) if x == PH else x, inp) self.assertEqual(nf(**val), f(**val)) nf = symbolic_trace(nf) self.assertEqual(nf(**val), f(**val)) def test_custom_codegen(self): class ListCodeGen(CodeGen): def gen_fn_def(self, free_vars, maybe_return_annotation): lst_unpack = f""" def forward(self, args_list: List[torch.Tensor]){maybe_return_annotation}: {', '.join(free_vars)} = args_list""" return lst_unpack def additional_globals(self): return [('List', typing.List)] def process_inputs(self, *inputs): assert(len(inputs) == 1) return inputs[0] def f(a, b): return a + b nf = symbolic_trace(f) vals = [torch.randn(3), torch.randn(3)] self.assertEqual(nf(*vals), f(*vals)) nf.graph.set_codegen(ListCodeGen()) nf.recompile() bare_fx = GraphModule({}, copy.deepcopy(nf.graph)) bare_fx.graph.set_codegen(CodeGen()) bare_fx.recompile() self.assertEqual(nf(vals), f(*vals)) self.assertEqual(nf.graph.process_outputs(bare_fx(*nf.graph.process_inputs(vals))), f(*vals)) ts_f = torch.jit.script(nf) self.assertEqual(nf(vals), ts_f(vals)) def test_imul_code_print(self): graph = torch.fx.Graph() a = graph.placeholder("a") b = graph.placeholder("b") graph.call_function(operator.imul, (a, b), {}) graph.output(a) gm = torch.fx.GraphModule({}, graph) gm.recompile() self.assertEqual(gm(2, 3), 6) self.assertIn("a *= b", gm.code) def run_getitem_target(): from torch.fx._symbolic_trace import _wrapped_methods_to_patch _wrapped_methods_to_patch.append((torch.Tensor, "__getitem__")) try: TestFX().getitem_inner() finally: _wrapped_methods_to_patch.pop() class TestOperatorSignatures(JitTestCase): def setUp(self): # Checking for mutable operations whil tracing is feature flagged # Enable it in testing but not by default self.orig_tracer_mutable_flag = torch.fx.proxy.TracerBase.check_mutable_operations torch.fx.proxy.TracerBase.check_mutable_operations = True def tearDown(self): torch.fx.proxy.TracerBase.check_mutable_operations = self.orig_tracer_mutable_flag @onlyCPU @ops(op_db, allowed_dtypes=(torch.float,)) def test_get_torch_func_signature_exhaustive(self, device, dtype, op): if not isinstance(op.op, types.BuiltinFunctionType): raise unittest.SkipTest("This path doesn't work on Python functions") sample_inputs_itr = op.sample_inputs(device, dtype, requires_grad=False) schemas = get_signature_for_torch_op(op.op) if not schemas: raise RuntimeError('No Schemas Returned') for sample_input in sample_inputs_itr: # Iterate through overloads until we hit a match. If we exit this # loop via `else`, we haven't found a match for schema in schemas: try: bound_args = schema.bind(sample_input.input, *sample_input.args, **sample_input.kwargs) bound_args.apply_defaults() op(*bound_args.args, **bound_args.kwargs) break except TypeError as e: pass else: raise RuntimeError(f'Did not match any schemas for op {op.name}!') class TestFXAPIBackwardCompatibility(JitTestCase): def setUp(self): self.maxDiff = None # Checking for mutable operations whil tracing is feature flagged # Enable it in testing but not by default self.orig_tracer_mutable_flag = torch.fx.proxy.TracerBase.check_mutable_operations torch.fx.proxy.TracerBase.check_mutable_operations = True def tearDown(self): torch.fx.proxy.TracerBase.check_mutable_operations = self.orig_tracer_mutable_flag def _fn_to_stable_annotation_str(self, obj): """ Unfortunately we have to serialize function signatures manually since serialization for `inspect.Signature` objects is not stable across python versions """ fn_name = torch.typename(obj) signature = inspect.signature(obj) sig_str = f'{fn_name}{signature}' arg_strs = [] for k, v in signature.parameters.items(): maybe_type_annotation = f': {self._annotation_type_to_stable_str(v.annotation, sig_str)}'\ if v.annotation is not inspect.Signature.empty else '' def default_val_str(val): if isinstance(val, (tuple, list)): str_pieces = ['(' if isinstance(val, tuple) else '['] str_pieces.append(', '.join(default_val_str(v) for v in val)) if isinstance(val, tuple) and len(str_pieces) == 2: str_pieces.append(',') str_pieces.append(')' if isinstance(val, tuple) else ']') return ''.join(str_pieces) # Need to fix up some default value strings. # First case: modules. Default module `repr` contains the FS path of the module. # Don't leak that if isinstance(val, types.ModuleType): return f'<module {val.__name__}>' # Second case: callables. Callables (such as lambdas) encode their address in # their string repr. Don't do that if callable(val): return f'<function {val.__name__}>' return str(val) if v.default is not inspect.Signature.empty: default_val_str = default_val_str(v.default) if not isinstance(v.default, str) else f"'{v.default}'" maybe_default = f' = {default_val_str}' else: maybe_default = '' maybe_stars = '' if v.kind == inspect.Parameter.VAR_POSITIONAL: maybe_stars = '*' elif v.kind == inspect.Parameter.VAR_KEYWORD: maybe_stars = '**' arg_strs.append(f'{maybe_stars}{k}{maybe_type_annotation}{maybe_default}') return_annot = f' -> {self._annotation_type_to_stable_str(signature.return_annotation, sig_str)}'\ if signature.return_annotation is not inspect.Signature.empty else '' return f'{fn_name}({", ".join(arg_strs)}){return_annot}' def _annotation_type_to_stable_str(self, t, sig_str): if t is inspect.Signature.empty: return '' # Forward ref if isinstance(t, str): return f"'{t}'" if hasattr(typing, 'ForwardRef') and isinstance(t, typing.ForwardRef): return t.__forward_arg__ if hasattr(typing, '_ForwardRef') and isinstance(t, typing._ForwardRef): return t.__forward_arg__ trivial_mappings = { str : 'str', int : 'int', float: 'float', bool: 'bool', torch.dtype: 'torch.dtype', torch.Tensor: 'torch.Tensor', torch.device: 'torch.device', torch.memory_format: 'torch.memory_format', slice: 'slice', torch.nn.Module: 'torch.nn.modules.module.Module', torch.fx.Graph : 'torch.fx.graph.Graph', torch.fx.Node : 'torch.fx.node.Node', torch.fx.Proxy : 'torch.fx.proxy.Proxy', torch.fx.node.Target : 'torch.fx.node.Target', torch.fx.node.Argument : 'torch.fx.node.Argument', torch.fx.graph.PythonCode : 'torch.fx.graph.PythonCode', torch.fx.graph_module.GraphModule: 'torch.fx.graph_module.GraphModule', torch.fx.subgraph_rewriter.Match: 'torch.fx.subgraph_rewriter.Match', Ellipsis : '...', typing.Any: 'Any', type(None): 'NoneType', None: 'None', typing.Iterator: 'Iterator', } mapping = trivial_mappings.get(t, None) if mapping: return mapping # Handle types with contained types contained = getattr(t, '__args__', None) or [] # Callables contain a bare List for arguments contained = t if isinstance(t, list) else contained # Python 3.8 puts type vars into __args__ for unbound types such as Dict if all(isinstance(ct, typing.TypeVar) for ct in contained): contained = [] contained_type_annots = [self._annotation_type_to_stable_str(ct, sig_str) for ct in contained] contained_type_str = f'[{", ".join(contained_type_annots)}]' if len(contained_type_annots) > 0 else '' origin = getattr(t, '__origin__', None) if origin is None: # Unbound types don't have `__origin__` in some Python versions, so fix that up here. origin = t if t in {typing.Tuple, typing.Union, typing.Dict, typing.List, typing.Type, typing.Callable} else origin if origin in {tuple, typing.Tuple}: return f'Tuple{contained_type_str}' if origin in {typing.Union}: # Annoying hack to detect Optional if len(contained) == 2 and (contained[0] is type(None)) ^ (contained[1] is type(None)): not_none_param = contained[0] if contained[0] is not type(None) else contained[1] return f'Optional[{self._annotation_type_to_stable_str(not_none_param, sig_str)}]' return f'Union{contained_type_str}' if origin in {dict, typing.Dict}: return f'Dict{contained_type_str}' if origin in {list, typing.List}: return f'List{contained_type_str}' if origin in {type, typing.Type}: return f'Type{contained_type_str}' if isinstance(t, typing.Callable): if len(contained) > 0 and contained[0] is not Ellipsis: return f'Callable[[{", ".join(contained_type_annots[:-1])}], {contained_type_annots[-1]}]' else: return f'Callable{contained_type_str}' raise RuntimeError(f'Unrecognized type {t} used in BC-compatible type signature {sig_str}.' f'Please add support for this type and confirm with the ' f'FX team that your signature change is valid.') def test_function_back_compat(self): """ Test backward compatibility for function signatures with @compatibility(is_backward_compatible=True). Currently this checks for exact signature matches, which may lead to false positives. If this becomes too annoying, we can refine this check to actually parse out the saved schema strings and check if the change is truly backward- incompatible. """ signature_strs = [] for obj in _BACK_COMPAT_OBJECTS: if not isinstance(obj, type): signature_strs.append(self._fn_to_stable_annotation_str(obj)) signature_strs.sort() try: self.assertExpected('\n'.join(signature_strs), 'fx_backcompat_function_signatures') except AssertionError as e: msg = f"{e}\n****** ERROR ******\nAn FX function that has been marked " \ f"as backwards-compatible has experienced a signature change. See the " \ f"above exception context for more information. If this change was " \ f"unintended, please revert it. If it was intended, check with the FX " \ f"team to ensure that the proper deprecation protocols have been followed " \ f"and subsequently --accept the change." raise AssertionError(msg) def test_class_member_back_compat(self): """ Test backward compatibility for members of classes with @compatibility(is_backward_compatible=True). Currently this checks for exact matches on the publicly visible members of the class. """ class_method_strs = [] for obj in _BACK_COMPAT_OBJECTS: if isinstance(obj, type): public_members = [name for name in obj.__dict__ if not name.startswith('_')] class_method_strs.append(f'{torch.typename(obj)} {sorted(public_members)}') class_method_strs.sort() try: self.assertExpected('\n'.join(class_method_strs), 'fx_backcompat_class_members') except AssertionError as e: msg = f"{e}\n****** ERROR ******\nAn FX class that has been marked " \ f"as backwards-compatible has experienced change in its public members. See the " \ f"above exception context for more information. If this change was " \ f"unintended, please revert it. If it was intended, check with the FX " \ f"team to ensure that the proper deprecation protocols have been followed " \ f"and subsequently --accept the change." raise AssertionError(msg) def test_public_api_surface(self): non_back_compat_objects = {} def check_symbols_have_bc_designation(m, prefix): if not m.__name__.startswith('torch.fx'): return if m.__name__.startswith('torch.fx.experimental'): return for k, v in m.__dict__.items(): if v is m: continue if k.startswith('_'): continue if isinstance(v, types.ModuleType): check_symbols_have_bc_designation(v, prefix + [k]) elif isinstance(v, type) or isinstance(v, types.FunctionType): if v not in _MARKED_WITH_COMATIBLITY: non_back_compat_objects.setdefault(v) check_symbols_have_bc_designation(torch.fx, ['torch', 'fx']) check_symbols_have_bc_designation(torch.fx.passes, ['torch', 'fx', 'passes']) non_back_compat_strs = [torch.typename(obj) for obj in non_back_compat_objects.keys()] # Only want objects in torch.fx non_back_compat_strs = [ s for s in non_back_compat_strs if s.startswith('torch.fx') and not s.startswith('torch.fx.experimental')] # Only want objects in public namespaces non_back_compat_strs = [ s for s in non_back_compat_strs if all(not atom.startswith('_') for atom in s.split('.'))] non_back_compat_strs.sort() if len(non_back_compat_strs) != 0: raise AssertionError(f"Public FX API(s) {non_back_compat_strs} introduced but not given a " f"backwards-compatibility classification! Please decorate these " f"API(s) with `@torch.fx._compatibility.compatibility` to specify " f"BC guarantees.") class TestFunctionalTracing(JitTestCase): def setUp(self): # Checking for mutable operations whil tracing is feature flagged # Enable it in testing but not by default self.orig_tracer_mutable_flag = torch.fx.proxy.TracerBase.check_mutable_operations torch.fx.proxy.TracerBase.check_mutable_operations = True def tearDown(self): torch.fx.proxy.TracerBase.check_mutable_operations = self.orig_tracer_mutable_flag IGNORE_FUNCS = ("has_torch_function", "has_torch_function_unary", "has_torch_function_variadic", "handle_torch_function", "boolean_dispatch") TO_PATCH = {"has_torch_function": None, "has_torch_function_unary": None, "has_torch_function_variadic": None} BUILT_IN_FUNC = (AssertionError, "") PROXY_ITERABLE = (TypeError, r"argument of type 'Proxy' is not iterable") PROXY_ITERATED = (TraceError, r"Proxy object cannot be iterated") LEN_ERROR = (RuntimeError, r"'len' is not supported in symbolic tracing by default") ARG_TYPE_MISMATCH = (TypeError, r", not Proxy$") CONTROL_FLOW = (TraceError, r"symbolically traced variables cannot be used as inputs to control flow") INTERPOLATE_ARGS_CONFLICT = (ValueError, r"only one of size or scale_factor should be defined") MUTABLE = (RuntimeError, r"Tried to trace mutable operation") UNTRACEABLE_FUNCTIONALS = { "adaptive_avg_pool1d": BUILT_IN_FUNC, "avg_pool1d": BUILT_IN_FUNC, "avg_pool2d": BUILT_IN_FUNC, "avg_pool3d": BUILT_IN_FUNC, "bilinear": BUILT_IN_FUNC, "celu_": BUILT_IN_FUNC, "channel_shuffle": BUILT_IN_FUNC, "native_channel_shuffle": BUILT_IN_FUNC, "conv1d": BUILT_IN_FUNC, "conv2d": BUILT_IN_FUNC, "conv3d": BUILT_IN_FUNC, "conv_tbc": BUILT_IN_FUNC, "conv_transpose1d": BUILT_IN_FUNC, "conv_transpose2d": BUILT_IN_FUNC, "conv_transpose3d": BUILT_IN_FUNC, "cosine_similarity": BUILT_IN_FUNC, "elu_": BUILT_IN_FUNC, "gelu": BUILT_IN_FUNC, "hardshrink": BUILT_IN_FUNC, "hardtanh_": BUILT_IN_FUNC, "leaky_relu_": BUILT_IN_FUNC, "linear": BUILT_IN_FUNC, "logsigmoid": BUILT_IN_FUNC, "one_hot": BUILT_IN_FUNC, "pairwise_distance": BUILT_IN_FUNC, "pdist": BUILT_IN_FUNC, "pixel_shuffle": BUILT_IN_FUNC, "pixel_unshuffle": BUILT_IN_FUNC, "prelu": BUILT_IN_FUNC, "relu_": BUILT_IN_FUNC, "rrelu_": BUILT_IN_FUNC, "selu_": BUILT_IN_FUNC, "softplus": BUILT_IN_FUNC, "softshrink": BUILT_IN_FUNC, "threshold_": BUILT_IN_FUNC, "adaptive_avg_pool2d": LEN_ERROR, "adaptive_avg_pool3d": LEN_ERROR, "adaptive_max_pool2d_with_indices": LEN_ERROR, "adaptive_max_pool3d_with_indices": LEN_ERROR, "instance_norm": CONTROL_FLOW, "pad": LEN_ERROR, "adaptive_max_pool1d": PROXY_ITERABLE, "adaptive_max_pool2d": PROXY_ITERABLE, "adaptive_max_pool3d": PROXY_ITERABLE, "fractional_max_pool2d": PROXY_ITERABLE, "fractional_max_pool3d": PROXY_ITERABLE, "max_pool1d": PROXY_ITERABLE, "max_pool2d": PROXY_ITERABLE, "max_pool3d": PROXY_ITERABLE, "group_norm": PROXY_ITERATED, "lp_pool2d": PROXY_ITERATED, "max_unpool1d": PROXY_ITERATED, "max_unpool2d": PROXY_ITERATED, "max_unpool3d": PROXY_ITERATED, "adaptive_max_pool1d_with_indices": ARG_TYPE_MISMATCH, "fractional_max_pool2d_with_indices": ARG_TYPE_MISMATCH, "fractional_max_pool3d_with_indices": ARG_TYPE_MISMATCH, "layer_norm": ARG_TYPE_MISMATCH, "lp_pool1d": ARG_TYPE_MISMATCH, "affine_grid": CONTROL_FLOW, "alpha_dropout": CONTROL_FLOW, "batch_norm": CONTROL_FLOW, "binary_cross_entropy": CONTROL_FLOW, "binary_cross_entropy_with_logits": CONTROL_FLOW, "celu": CONTROL_FLOW, "cosine_embedding_loss": CONTROL_FLOW, "cross_entropy": CONTROL_FLOW, "ctc_loss": CONTROL_FLOW, "dropout": CONTROL_FLOW, "dropout2d": CONTROL_FLOW, "dropout3d": CONTROL_FLOW, "elu": CONTROL_FLOW, "embedding": CONTROL_FLOW, "embedding_bag": CONTROL_FLOW, "feature_alpha_dropout": CONTROL_FLOW, "fold": CONTROL_FLOW, "gaussian_nll_loss": CONTROL_FLOW, "glu": CONTROL_FLOW, "grid_sample": CONTROL_FLOW, "gumbel_softmax": CONTROL_FLOW, "hardsigmoid": CONTROL_FLOW, "hardswish": CONTROL_FLOW, "hardtanh": CONTROL_FLOW, "hinge_embedding_loss": CONTROL_FLOW, "huber_loss": CONTROL_FLOW, "interpolate": CONTROL_FLOW, "kl_div": CONTROL_FLOW, "l1_loss": CONTROL_FLOW, "leaky_relu": CONTROL_FLOW, "local_response_norm": CONTROL_FLOW, "margin_ranking_loss": CONTROL_FLOW, "max_pool1d_with_indices": CONTROL_FLOW, "max_pool2d_with_indices": CONTROL_FLOW, "max_pool3d_with_indices": CONTROL_FLOW, "mse_loss": CONTROL_FLOW, "multi_head_attention_forward": CONTROL_FLOW, "multi_margin_loss": CONTROL_FLOW, "multilabel_margin_loss": CONTROL_FLOW, "multilabel_soft_margin_loss": CONTROL_FLOW, "nll_loss": CONTROL_FLOW, "poisson_nll_loss": CONTROL_FLOW, "relu": CONTROL_FLOW, "relu6": CONTROL_FLOW, "rrelu": CONTROL_FLOW, "selu": CONTROL_FLOW, "silu": CONTROL_FLOW, "mish": CONTROL_FLOW, "smooth_l1_loss": CONTROL_FLOW, "soft_margin_loss": CONTROL_FLOW, "threshold": CONTROL_FLOW, "triplet_margin_loss": CONTROL_FLOW, "triplet_margin_with_distance_loss": CONTROL_FLOW, "unfold": CONTROL_FLOW, "upsample": CONTROL_FLOW, "upsample_bilinear": INTERPOLATE_ARGS_CONFLICT, "upsample_nearest": INTERPOLATE_ARGS_CONFLICT, "normalize" : MUTABLE, } # List of nn.functionals with Tensor inputs but not with type annotation FUNCTIONALS_WITHOUT_ANNOTATION = ( "adaptive_max_pool1d", "adaptive_max_pool2d", "adaptive_max_pool3d", "fractional_max_pool2d", "fractional_max_pool3d", "max_pool1d", "max_pool2d", "max_pool3d", "gaussian_nll_loss", "upsample", "upsample_bilinear", "upsample_nearest", ) # Inconsistent behavior between Python 3.8 and other Python versions: # - Python 3.8+: Re-raise internal exception like `PROXY_ITERATED` # - Other Python: Raise `argument of type 'Proxy' is not iterable` due to the same # internal exception above # Use the following map to override the expected exception for Python 3.8 UNTRACEABLE_FUNCTIONALS_PY38 = { "adaptive_max_pool1d": PROXY_ITERATED, "adaptive_max_pool2d": PROXY_ITERATED, "adaptive_max_pool3d": PROXY_ITERATED, "fractional_max_pool2d": PROXY_ITERATED, "fractional_max_pool3d": PROXY_ITERATED, "max_pool1d": PROXY_ITERATED, "max_pool2d": PROXY_ITERATED, "max_pool3d": PROXY_ITERATED, "group_norm": LEN_ERROR } @classmethod def _get_functional(cls): functional_list = [] for f in dir(torch.nn.functional): if not f.islower(): continue # Ignore internal functions if f.startswith('_'): continue # Ignore supporting functions if f in cls.IGNORE_FUNCS: continue fn = getattr(torch.nn.functional, f) # Ignore non-callable object like modules if not isinstance(fn, Callable): continue if f not in cls.FUNCTIONALS_WITHOUT_ANNOTATION: try: sig = inspect.signature(fn) has_tensor_arg = False for arg, param in sig.parameters.items(): if isinstance(param.annotation, type) and issubclass(param.annotation, torch.Tensor): has_tensor_arg = True if not has_tensor_arg: continue # No signature or Object is not supported except ValueError: pass functional_list.append((f, fn)) return functional_list @classmethod def generate_test_func(cls, func_name, fn): def functional_test(self): if func_name in self.UNTRACEABLE_FUNCTIONALS_PY38 and \ sys.version_info >= (3, 8) and sys.version_info < (3, 10): exc, err = self.UNTRACEABLE_FUNCTIONALS_PY38[func_name] with self.assertRaisesRegex(exc, err): symbolic_trace(fn) elif func_name in self.UNTRACEABLE_FUNCTIONALS: exc, err = self.UNTRACEABLE_FUNCTIONALS[func_name] with self.assertRaisesRegex(exc, err): symbolic_trace(fn) else: symbolic_trace(fn) return functional_test @classmethod def generate_tests(cls): functional_list = cls._get_functional() for func_name, fn in functional_list: test_name = "test_nn_functional_" + func_name functional_test = cls.generate_test_func(func_name, fn) setattr(cls, test_name, functional_test) @classmethod def setUpClass(cls): def no(*args, **kwargs): return False for name in cls.TO_PATCH.keys(): cls.TO_PATCH[name] = getattr(torch.nn.functional, name) setattr(torch.nn.functional, name, no) @classmethod def tearDownClass(cls): for name in cls.TO_PATCH.keys(): setattr(torch.nn.functional, name, cls.TO_PATCH[name]) TestFunctionalTracing.generate_tests() instantiate_device_type_tests(TestOperatorSignatures, globals()) @skipIfNoTorchVision class TestVisionTracing(JitTestCase): def setUp(self): # Checking for mutable operations whil tracing is feature flagged # Enable it in testing but not by default self.orig_tracer_mutable_flag = torch.fx.proxy.TracerBase.check_mutable_operations torch.fx.proxy.TracerBase.check_mutable_operations = True def tearDown(self): torch.fx.proxy.TracerBase.check_mutable_operations = self.orig_tracer_mutable_flag PROXY_ITERATED = (TraceError, r"Proxy object cannot be iterated") INCONSISTENT_TYPE = ( RuntimeError, r"Return value was annotated as having type __torch__.torchvision.models[.\w]+ but is actually of type Tensor" ) UNTRACEABLE_MODELS = { "fasterrcnn_resnet50_fpn": PROXY_ITERATED, "fasterrcnn_mobilenet_v3_large_320_fpn": PROXY_ITERATED, "fasterrcnn_mobilenet_v3_large_fpn": PROXY_ITERATED, "maskrcnn_resnet50_fpn": PROXY_ITERATED, "keypointrcnn_resnet50_fpn": PROXY_ITERATED, "retinanet_resnet50_fpn": PROXY_ITERATED, } UNSCRIPTABLE_MODELS = { "googlenet": INCONSISTENT_TYPE, "inception_v3": INCONSISTENT_TYPE, } output_transform = { "fcn_resnet50": lambda x: x["out"], "fcn_resnet101": lambda x: x["out"], "deeplabv3_resnet50": lambda x: x["out"], "deeplabv3_resnet101": lambda x: x["out"], "deeplabv3_mobilenet_v3_large": lambda x: x["out"], "lraspp_mobilenet_v3_large": lambda x: x["out"], "fasterrcnn_resnet50_fpn": lambda x: x[1], "fasterrcnn_mobilenet_v3_large_fpn": lambda x: x[1], "fasterrcnn_mobilenet_v3_large_320_fpn": lambda x: x[1], "maskrcnn_resnet50_fpn": lambda x: x[1], "keypointrcnn_resnet50_fpn": lambda x: x[1], "retinanet_resnet50_fpn": lambda x: x[1], } @classmethod def generate_test_fn(cls, name, model_fn, x, kwargs): def run_test(self): model = model_fn(**kwargs) model = model.eval() if name in self.UNTRACEABLE_MODELS: err, exc = self.UNTRACEABLE_MODELS[name] with self.assertRaisesRegex(err, exc): graph = symbolic_trace(model) else: out_transform = self.output_transform.get(name, lambda x: x) graph : torch.fx.GraphModule = symbolic_trace(model) a = out_transform(model(x)) b = out_transform(graph(x)) self.assertEqual(a, b) if name in self.UNSCRIPTABLE_MODELS: err, exc = self.UNSCRIPTABLE_MODELS[name] with self.assertRaisesRegex(err, exc): script = torch.jit.script(graph) else: script = torch.jit.script(graph) c = out_transform(script(x)) self.assertEqual(a, c) return run_test @classmethod def generate_classification_tests(cls): for k, v in torchvision_models.__dict__.items(): if callable(v) and k[0].lower() == k[0] and k[0] != "_": test_name = 'test_torchvision_models_' + k x = torch.rand(1, 3, 299, 299) if k in ['inception_v3'] else torch.rand(1, 3, 224, 224) kwargs = dict(num_classes=50) model_test = cls.generate_test_fn(k, v, x, kwargs) setattr(cls, test_name, model_test) @classmethod def generate_segmentation_tests(cls): for k, v in torchvision_models.segmentation.__dict__.items(): if callable(v) and k[0].lower() == k[0] and k[0] != "_": test_name = 'test_torchvision_models_segmentation_' + k x = torch.rand(1, 3, 32, 32) kwargs = dict(num_classes=10, pretrained_backbone=False) model_test = cls.generate_test_fn(k, v, x, kwargs) setattr(cls, test_name, model_test) @classmethod def generate_detection_tests(cls): for k, v in torchvision_models.detection.__dict__.items(): if callable(v) and k[0].lower() == k[0] and k[0] != "_": test_name = 'test_torchvision_models_detection_' + k x = [torch.rand(3, 300, 300)] kwargs = dict(num_classes=10, pretrained_backbone=False) model_test = cls.generate_test_fn(k, v, x, kwargs) setattr(cls, test_name, model_test) @classmethod def generate_video_tests(cls): for k, v in torchvision_models.video.__dict__.items(): if callable(v) and k[0].lower() == k[0] and k[0] != "_": test_name = 'test_torchvision_models_video_' + k x = torch.rand(1, 3, 4, 112, 112) kwargs = dict(num_classes=50) model_test = cls.generate_test_fn(k, v, x, kwargs) setattr(cls, test_name, model_test) @classmethod def generate_tests(cls): cls.generate_classification_tests() cls.generate_detection_tests() cls.generate_segmentation_tests() cls.generate_video_tests() if HAS_TORCHVISION: TestVisionTracing.generate_tests() if __name__ == '__main__': run_tests()
test_is_valid_binary_search_tree.py
import unittest from typing import List from is_valid_binary_search_tree import Solution, TreeNode class TestSolution(unittest.TestCase): def setUp(self): pass def tearDown(self): pass def
(self): sol = Solution() root = sol.get_tree([1],0) self.assertTrue(sol.isValidBST(root)) def test_isValidBST_when_tree_is_BST_should_return_true(self): sol = Solution() root = sol.get_tree([6,2,9,1,3,8,10],0) self.assertTrue(sol.isValidBST(root)) if __name__ == '__main__': unittest.main()
test_isValidBST_when_tree_has_single_node_should_return_true
netsmf.py
import numpy as np import networkx as nx import scipy.sparse as sp from sklearn import preprocessing from sklearn.utils.extmath import randomized_svd from multiprocessing import Pool from tqdm import tqdm import time from cogdl.utils import alias_draw, alias_setup from .. import BaseModel class NetSMF(BaseModel): r"""The NetSMF model from the `"NetSMF: Large-Scale Network Embedding as Sparse Matrix Factorization" <http://arxiv.org/abs/1710.02971>`_ paper. Args: hidden_size (int) : The dimension of node representation. window_size (int) : The actual context size which is considered in language model. negative (int) : The number of nagative samples in negative sampling. num_round (int) : The number of round in NetSMF. worker (int) : The number of workers for NetSMF. """ @staticmethod def add_args(parser): """Add model-specific arguments to the parser.""" # fmt: off parser.add_argument("--window-size", type=int, default=10, help="Window size of approximate matrix. Default is 10.") parser.add_argument("--negative", type=int, default=1, help="Number of negative node in sampling. Default is 1.") parser.add_argument("--num-round", type=int, default=100, help="Number of round in NetSMF. Default is 100.") parser.add_argument("--worker", type=int, default=10, help="Number of parallel workers. Default is 10.") parser.add_argument("--hidden-size", type=int, default=128) # fmt: on @classmethod def build_model_from_args(cls, args): return cls( args.hidden_size, args.window_size, args.negative, args.num_round, args.worker, ) def __init__(self, dimension, window_size, negative, num_round, worker): super(NetSMF, self).__init__() self.dimension = dimension self.window_size = window_size self.negative = negative self.worker = worker self.num_round = num_round def train(self, graph, return_dict=False): return self.forward(graph, return_dict) def forward(self, graph, return_dict=False): self.G = graph.to_networkx() node2id = dict([(node, vid) for vid, node in enumerate(self.G.nodes())]) self.is_directed = nx.is_directed(self.G) self.num_node = self.G.number_of_nodes() self.num_edge = self.G.number_of_edges() self.edges = [[node2id[e[0]], node2id[e[1]]] for e in self.G.edges()] id2node = dict(zip(node2id.values(), node2id.keys())) self.num_neigh = np.asarray([len(list(self.G.neighbors(id2node[i]))) for i in range(self.num_node)]) self.neighbors = [[node2id[v] for v in self.G.neighbors(id2node[i])] for i in range(self.num_node)] s = time.time() self.alias_nodes = {} self.node_weight = {} for i in range(self.num_node): unnormalized_probs = [self.G[id2node[i]][nbr].get("weight", 1.0) for nbr in self.G.neighbors(id2node[i])] norm_const = sum(unnormalized_probs) normalized_probs = [float(u_prob) / norm_const for u_prob in unnormalized_probs] self.alias_nodes[i] = alias_setup(normalized_probs) self.node_weight[i] = dict( zip( [node2id[nbr] for nbr in self.G.neighbors(id2node[i])], unnormalized_probs, ) ) t = time.time() print("alias_nodes", t - s) # run netsmf algorithm with multiprocessing and apply randomized svd print("number of sample edges ", self.num_round * self.num_edge * self.window_size) print("random walk start...") t0 = time.time() results = [] pool = Pool(processes=self.worker) for i in range(self.worker): results.append(pool.apply_async(func=self._random_walk_matrix, args=(i,))) pool.close() pool.join() print("random walk time", time.time() - t0) matrix = sp.csr_matrix((self.num_node, self.num_node)) A = sp.csr_matrix(nx.adjacency_matrix(self.G)) degree = sp.diags(np.array(A.sum(axis=0))[0], format="csr") degree_inv = degree.power(-1) t1 = time.time() for res in results: matrix += res.get() t2 = time.time() print("construct random walk matrix time", time.time() - t1) L = sp.csgraph.laplacian(matrix, normed=False, return_diag=False) M = degree_inv.dot(degree - L).dot(degree_inv) M = M * A.sum() / self.negative M.data[M.data <= 1] = 1 M.data = np.log(M.data) M.eliminate_zeros() print("number of nzz", M.nnz) print("construct matrix sparsifier time", time.time() - t2) embeddings = self._get_embedding_rand(M) if return_dict: features_matrix = dict() for vid, node in enumerate(self.G.nodes()): features_matrix[node] = embeddings[vid] else: features_matrix = np.zeros((graph.num_nodes, embeddings.shape[1])) nx_nodes = self.G.nodes() features_matrix[nx_nodes] = embeddings[np.arange(graph.num_nodes)] return features_matrix def _get_embedding_rand(self, matrix): # Sparse randomized tSVD for fast embedding
def _path_sampling(self, u, v, r): # sample a r-length path from edge(u, v) and return path end node k = np.random.randint(r) + 1 zp, rand_u, rand_v = 2.0 / self.node_weight[u][v], k - 1, r - k for i in range(rand_u): new_u = self.neighbors[u][alias_draw(self.alias_nodes[u][0], self.alias_nodes[u][1])] zp += 2.0 / self.node_weight[u][new_u] u = new_u for j in range(rand_v): new_v = self.neighbors[v][alias_draw(self.alias_nodes[v][0], self.alias_nodes[v][1])] zp += 2.0 / self.node_weight[v][new_v] v = new_v return u, v, zp def _random_walk_matrix(self, pid): # construct matrix based on random walk np.random.seed(pid) matrix = sp.lil_matrix((self.num_node, self.num_node)) for i in tqdm(range(self.num_edge * self.num_round // self.worker)): u, v = self.edges[i % self.num_edge] if not self.is_directed and np.random.rand() > 0.5: v, u = u, v for r in range(1, self.window_size + 1): u_, v_, zp = self._path_sampling(u, v, r) matrix[u_, v_] += 2 * r / self.window_size / self.num_round / zp return matrix.tocsr()
t1 = time.time() l = matrix.shape[0] # noqa E741 smat = sp.csc_matrix(matrix) print("svd sparse", smat.data.shape[0] * 1.0 / l ** 2) U, Sigma, VT = randomized_svd(smat, n_components=self.dimension, n_iter=5, random_state=None) U = U * np.sqrt(Sigma) U = preprocessing.normalize(U, "l2") print("sparsesvd time", time.time() - t1) return U
source.go
// Copyright 2020 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package importer import ( "compress/gzip" "net/url" "regexp" "strings" "github.com/GoogleCloudPlatform/compute-image-tools/cli_tools/common/domain" "github.com/GoogleCloudPlatform/compute-image-tools/cli_tools/common/utils/param" "github.com/GoogleCloudPlatform/compute-image-tools/cli_tools/common/utils/storage" "github.com/GoogleCloudPlatform/compute-image-tools/cli_tools/daisycommon" "github.com/GoogleCloudPlatform/compute-image-tools/daisy" ) // Source is a resource that can be imported to GCE disk images. If an instance of this // interface exists, it is expected that validation has already occurred, // and that the caller can safely use the resource. // //go:generate go run github.com/golang/mock/mockgen -package imagemocks -source $GOFILE -destination mocks/source_mocks.go type Source interface { Path() string } // SourceFactory takes the sourceFile and sourceImage specified by the user // and determines which, if any, is importable. It is an error if both sourceFile and // sourceImage are specified. type SourceFactory interface { Init(sourceFile, sourceImage string) (Source, error) } // NewSourceFactory returns an instance of SourceFactory. func NewSourceFactory(storageClient domain.StorageClientInterface) SourceFactory { return sourceFactory{storageClient: storageClient} } type sourceFactory struct { storageClient domain.StorageClientInterface } func (factory sourceFactory) Init(sourceFile, sourceImage string) (Source, error) { sourceFile = strings.TrimSpace(sourceFile) sourceImage = strings.TrimSpace(sourceImage) if sourceFile == "" && sourceImage == "" { return nil, daisy.Errf( "either -source_file or -source_image has to be specified") } if sourceFile != "" && sourceImage != "" { return nil, daisy.Errf( "either -source_file or -source_image has to be specified, but not both %v %v", sourceFile, sourceImage) } if sourceFile != "" { return newFileSource(sourceFile, factory.storageClient) } return newImageSource(sourceImage) } // Whether the resource is a file in GCS. func isFile(s Source) bool { _, ok := s.(fileSource) return ok } // Whether the resource is a GCE image. func
(s Source) bool { _, ok := s.(imageSource) return ok } // An importable source backed by a GCS object. type fileSource struct { gcsPath string bucket string object string } // Create a fileSource from a gcsPath to a disk image. This method uses storageClient // to read a few bytes from the file. It is an error if the file is empty, or if // the file is compressed with gzip. func newFileSource(gcsPath string, storageClient domain.StorageClientInterface) (Source, error) { sourceBucketName, sourceObjectName, err := storage.GetGCSObjectPathElements(gcsPath) if err != nil { return nil, err } source := fileSource{ gcsPath: gcsPath, bucket: sourceBucketName, object: sourceObjectName, } return source, source.validate(storageClient) } // The resource path for fileSource is its GCS path. func (s fileSource) Path() string { return s.gcsPath } // Performs basic validation, focusing on error cases that we've seen in the past. // This reads a few bytes from the file in GCS. It is an error if the file // is empty, or if the file is compressed with gzip. func (s fileSource) validate(storageClient domain.StorageObjectCreatorInterface) error { rc, err := storageClient.GetObject(s.bucket, s.object).NewReader() if err != nil { return daisy.Errf("failed to read GCS file when validating resource file: unable to open "+ "file from bucket %q, file %q: %v", s.bucket, s.object, err) } defer rc.Close() byteCountingReader := daisycommon.NewByteCountingReader(rc) // Detect whether it's a compressed file by extracting compressed file header if _, err = gzip.NewReader(byteCountingReader); err == nil { return daisy.Errf("the input file is a gzip file, which is not supported by " + "image import. To import a file that was exported from Google Compute " + "Engine, please use image create. To import a file that was exported " + "from a different system, decompress it and run image import on the " + "disk image file directly") } // By calling gzip.NewReader above, a few bytes were read from the Reader in // an attempt to decode the compression header. If the Reader represents // an empty file, then BytesRead will be zero. if byteCountingReader.BytesRead <= 0 { return daisy.Errf("cannot import an image from an empty file") } return nil } // An importable source backed by a GCE disk image. type imageSource struct { uri string } // Creates an imageSource from a reference to a GCE disk image. The syntax of the // reference is validated, but no I/O is performed to determine whether the image // exists or whether the calling user has access to it. func newImageSource(imagePath string) (Source, error) { source := imageSource{ uri: param.GetGlobalResourcePath("images", imagePath), } return source, source.validate() } var imageNamePattern = regexp.MustCompile("^[a-z]([-a-z0-9]*[a-z0-9])?$") // Performs basic validation, focusing on error cases that // we've seen in the past. Specifically: // 1. Using GCS paths, eg `gs://bucket/image.vmdk` // 2. Referencing a file, eg `image.vmdk` // // This method does not validate: // 1. Whether the image exists. // 2. Whether the calling user has access to it. // 3. Whether the user's input is a well-formed // [GCP resource URI](https://cloud.google.com/apis/design/resource_names) func (s imageSource) validate() error { parsed, err := url.Parse(s.uri) if err != nil { return err } if parsed.Scheme != "" { return daisy.Errf( "invalid image reference %q.", s.uri) } var imageName string if slash := strings.LastIndex(s.uri, "/"); slash > -1 { imageName = s.uri[slash+1:] } else { imageName = s.uri } if imageName == "" || len(imageName) > 63 { return daisy.Errf( "invalid image name %q. Image name must be 1-63 characters long, inclusive", imageName) } if !imageNamePattern.MatchString(imageName) { return daisy.Errf( "invalid image name %q. The first character must be a lowercase letter, and all "+ "following characters must be a dash, lowercase letter, or digit, except the last "+ "character, which cannot be a dash.", imageName) } return nil } // The path to an imageSource is a fully-qualified global GCP resource path. func (s imageSource) Path() string { return s.uri }
isImage
msequence.py
# # msequence.py # Created by pira on 2017/07/28. # #coding: utf-8 u"""For M-Sequence.""" import numpy as np def generateM(N): u"""Create M-Sequence. @param N : length 2**N-1 @return m : M-Sequence """ p = pow(2, N) m = [0] * (p-1) for i in np.arange(1,p,2): f = p^i a = p #i = int() for j in np.arange(N, p): if (a&p) == p:
if a == 1: break a <<= 1 if j == p-1: init = 1 lfsr = init & (p-1) f >>= 1 for k in np.arange(0, p-1): lfsr = (lfsr>>1)^(-(int)(lfsr&1) & f) m[k] = (lfsr&1) * 2-1 return m #test #m = generateM(3) #print(m)
a ^= f
synchronizer_test.go
/* Copyright 2021 Gravitational, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package docker import ( "context" "fmt" "os" "sort" "github.com/gravitational/gravity/lib/archive" "github.com/gravitational/gravity/lib/loc" "github.com/gravitational/gravity/lib/utils" . "gopkg.in/check.v1" dockerapi "github.com/fsouza/go-dockerclient" "github.com/sirupsen/logrus" ) // Set up a separate Suite for this test so we can use SetUp/TearDown phases type DockerSuite struct { client *dockerapi.Client helper *Synchronizer src, dst *registryHelper } func (s *DockerSuite) SetUpTest(c *C) { var err error s.client, err = NewClientFromEnv() c.Assert(err, IsNil) s.helper = NewSynchronizer(logrus.New(), s.client, utils.DiscardProgress) // Set up source and destination registries s.src = newRegistry(c.MkDir(), s.helper, c) s.dst = newRegistry(c.MkDir(), s.helper, c) } func (s *DockerSuite) TearDownTest(*C) { s.src.r.Close() s.dst.r.Close() } func (s *DockerSuite) listTags(repository string, c *C) (tags map[string]bool) { opts := dockerapi.ListImagesOptions{Filters: map[string][]string{ "reference": {repository}, }} images, err := s.client.ListImages(opts) c.Assert(err, IsNil) tags = make(map[string]bool) for _, image := range images { for _, imageName := range image.RepoTags { dockerImage, err := loc.ParseDockerImage(imageName) c.Assert(err, IsNil) tags[dockerImage.Tag] = true } } return tags } // newRegistry returns a new started docker registry func newRegistry(dir string, s *Synchronizer, c *C) *registryHelper { config := BasicConfiguration("127.0.0.1:0", dir) r, err := NewRegistry(config) c.Assert(err, IsNil) c.Assert(r.Start(), IsNil) return &registryHelper{ r: r, dir: dir, info: RegistryInfo{ Address: r.Addr(), Protocol: "http", }, helper: s, } } func generateDockerImage(client *dockerapi.Client, repoName, tag string, c *C) loc.DockerImage { image := loc.DockerImage{ Repository: repoName, Tag: tag, } imageName := image.String() files := make([]*archive.Item, 0) files = append(files, archive.ItemFromStringMode("version.txt", tag, 0666)) dockerFile := "FROM scratch\nCOPY version.txt .\n" files = append(files, archive.ItemFromStringMode("Dockerfile", dockerFile, 0666)) r := archive.MustCreateMemArchive(files) c.Assert(client.BuildImage(dockerapi.BuildImageOptions{ Name: imageName, InputStream: r, OutputStream: os.Stdout, }), IsNil) return image } func generateDockerImages(client *dockerapi.Client, repoName string, size int, c *C) []loc.DockerImage
func (s *DockerSuite) removeImages(images []loc.DockerImage) { for _, image := range images { // Error is ignored since this is a best-effort cleanup _ = s.client.RemoveImage(image.String()) } } func (s *DockerSuite) removeTaggedImages(registryAddr string, images []loc.DockerImage) { for _, image := range images { // Error is ignored since this is a best-effort cleanup image.Registry = registryAddr _ = s.client.RemoveImage(image.String()) } } func (r *registryHelper) push(image loc.DockerImage, c *C) { c.Assert(r.helper.Push(image.String(), r.r.Addr()), IsNil) } func (r *registryHelper) pushImages(images []loc.DockerImage, c *C) { for _, image := range images { r.push(image, c) } } type registryHelper struct { dir string r *Registry info RegistryInfo helper *Synchronizer } func splitAsTagsAndImages(images []loc.DockerImage, regAddr string) (tags, exportedImages []string) { for _, image := range images { tags = append(tags, image.Tag) exportedImage := image exportedImage.Registry = regAddr exportedImages = append(exportedImages, exportedImage.String()) } sort.Strings(tags) return tags, exportedImages } const imageRepository = "test/image" var _ = Suite(&DockerSuite{}) func (s *DockerSuite) TestPullAndPushImages(c *C) { // Setup const dockerImageSize = 6 dockerImages := generateDockerImages(s.client, imageRepository, dockerImageSize, c) defer s.removeImages(dockerImages) defer s.removeTaggedImages(s.src.info.Address, dockerImages) // the first 3 docker images are pushed to both registries var pushedDockerTags []string for _, image := range dockerImages[:3] { s.src.push(image, c) s.dst.push(image, c) pushedDockerTags = append(pushedDockerTags, image.Tag) } sort.Strings(pushedDockerTags) // the last docker images are pushed only to the source registry var unpushedDockerTags []string for _, image := range dockerImages[3:] { s.src.push(image, c) unpushedDockerTags = append(unpushedDockerTags, image.Tag) } allDockerTags, exportedImages := splitAsTagsAndImages(dockerImages, s.src.r.Addr()) srcImageRepository := fmt.Sprintf("%s/%s", s.src.r.Addr(), imageRepository) localImageTags := s.listTags(srcImageRepository, c) // generated docker images should not be in the local docker registry for _, tag := range allDockerTags { if localImageTags[tag] { c.Errorf("image %s:%s should not be in the local docker registry", imageRepository, tag) } } // all docker images should be in the source docker registry srcTags, err := s.helper.ImageTags(context.Background(), s.src.info.GetURL(), imageRepository) c.Assert(err, IsNil) sort.Strings(srcTags) c.Assert(srcTags, DeepEquals, allDockerTags) // only pushed docker images should be in the target docker registry dstTags, err := s.helper.ImageTags(context.Background(), s.dst.info.GetURL(), imageRepository) c.Assert(err, IsNil) sort.Strings(dstTags) c.Assert(dstTags, DeepEquals, pushedDockerTags) // export images err = s.helper.PullAndExportImages(context.Background(), exportedImages, s.dst.info, false, dockerImageSize) c.Assert(err, IsNil) // Validate: this is where actual validation starts // relist tags localImageTags = s.listTags(srcImageRepository, c) // only unpushed docker images should not be in the local docker registry for _, tag := range unpushedDockerTags { if !localImageTags[tag] { c.Errorf("image %s:%s should be in the local docker registry", srcImageRepository, tag) } } for _, tag := range pushedDockerTags { if localImageTags[tag] { c.Errorf("image %s:%s should not be in the local docker registry", srcImageRepository, tag) } } // all docker images should be in the target docker registry dstTags, err = s.helper.ImageTags(context.Background(), s.dst.info.GetURL(), imageRepository) c.Assert(err, IsNil) sort.Strings(dstTags) c.Assert(dstTags, DeepEquals, allDockerTags) }
{ // Use a predictable tagging scheme imageTag := func(i int) string { return fmt.Sprintf("v0.0.%d", i) } images := make([]loc.DockerImage, 0, size) for i := 0; i < size; i++ { image := generateDockerImage(client, repoName, imageTag(i), c) images = append(images, image) } return images }
flat_map.rs
// Copyright Materialize, Inc. All rights reserved. // // Use of this software is governed by the Business Source License // included in the LICENSE file. // // As of the Change Date specified in that file, in accordance with // the Business Source License, use of this software will be governed // by the Apache License, Version 2.0. use differential_dataflow::Collection; use timely::dataflow::Scope; use dataflow_types::*; use expr::MirRelationExpr; use repr::{Datum, Row, RowArena}; use crate::operator::StreamExt; use crate::render::context::Context; use crate::render::datum_vec::DatumVec; impl<G> Context<G, MirRelationExpr, Row, repr::Timestamp> where G: Scope<Timestamp = repr::Timestamp>, { /// Renders `relation_expr` followed by `map_filter_project` if provided. pub fn render_flat_map( &mut self, relation_expr: &MirRelationExpr, map_filter_project: Option<expr::MfpPlan>, ) -> (Collection<G, Row>, Collection<G, DataflowError>) { if let MirRelationExpr::FlatMap { input, func, exprs, demand, } = relation_expr { let func = func.clone(); let exprs = exprs.clone(); // Determine for each output column if it should be replaced by a // small default value. This information comes from the "demand" // analysis, and is meant to allow us to avoid reproducing the // input in each output, if at all possible. let types = relation_expr.typ(); let arity = types.column_types.len(); let replace = (0..arity) .map(|col| !demand.as_ref().map(|d| d.contains(&col)).unwrap_or(true)) .collect::<Vec<_>>(); let (ok_collection, err_collection) = self.collection(input).unwrap(); let (oks, errs) = ok_collection.inner.flat_map_fallible({ let mut datums = DatumVec::new(); let mut row_packer = repr::Row::default(); move |(input_row, time, diff)| { let temp_storage = RowArena::new(); // Unpack datums and capture its length (to rewind MFP eval). let mut datums_local = datums.borrow_with(&input_row); let datums_len = datums_local.len(); let exprs = exprs .iter() .map(|e| e.eval(&datums_local, &temp_storage)) .collect::<Result<Vec<_>, _>>(); let exprs = match exprs { Ok(exprs) => exprs, Err(e) => return vec![(Err((e.into(), time, diff)))], }; let output_rows = func.eval(exprs, &temp_storage); // Blank out entries in `datum` here, for simplicity later on. for index in 0..datums_len { if replace[index] { datums_local[index] = Datum::Dummy; } } // Declare borrows outside the closure so that appropriately lifetimed // borrows are moved in and used by `mfp.evaluate`. let map_filter_project = &map_filter_project; let row_packer = &mut row_packer; let temp_storage = &temp_storage; let replace = &replace; if let Some(mfp) = map_filter_project { output_rows .iter() .flat_map(move |(output_row, r)| { // Remove any additional columns added in prior evaluation. datums_local.truncate(datums_len); // Extend datums with additional columns, replace some with dummy values. datums_local.extend(output_row.iter()); for index in datums_len..datums_local.len() { if replace[index] { datums_local[index] = Datum::Dummy; } } mfp.evaluate(&mut datums_local, temp_storage, time, diff * *r) .map(|x| x.map_err(|(e, t, r)| (DataflowError::from(e), t, r))) }) .collect::<Vec<_>>() } else { output_rows .iter() .map(move |(output_row, r)| { Ok(( { row_packer.extend( datums_local .iter() .cloned() .chain(output_row.iter()) .zip(replace.iter()) .map( |(datum, replace)| { if *replace { Datum::Dummy } else { datum } }, ), ); row_packer.finish_and_reuse() }, time, diff * *r, )) }) .collect::<Vec<_>>() } // The collection avoids the lifetime issues of the `datums` borrow, // which allows us to avoid multiple unpackings of `input_row`. We // could avoid this allocation with a custom iterator that understands // the borrowing, but it probably isn't the leading order issue here. } }); use differential_dataflow::AsCollection; let ok_collection = oks.as_collection();
} else { panic!("Non-FlatMap expression provided to `render_flat_map`"); } } }
let new_err_collection = errs.as_collection(); let err_collection = err_collection.concat(&new_err_collection); (ok_collection, err_collection)
virtual_machine_scale_set_py3.py
# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- from .resource_py3 import Resource class VirtualMachineScaleSet(Resource): """Describes a Virtual Machine Scale Set. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. :ivar id: Resource Id :vartype id: str :ivar name: Resource name :vartype name: str :ivar type: Resource type :vartype type: str :param location: Required. Resource location :type location: str :param tags: Resource tags :type tags: dict[str, str] :param sku: The virtual machine scale set sku. :type sku: ~azure.mgmt.compute.v2018_06_01.models.Sku :param plan: Specifies information about the marketplace image used to create the virtual machine. This element is only used for marketplace images. Before you can use a marketplace image from an API, you must enable the image for programmatic use. In the Azure portal, find the marketplace image that you want to use and then click **Want to deploy programmatically, Get Started ->**. Enter any required information and then click **Save**. :type plan: ~azure.mgmt.compute.v2018_06_01.models.Plan :param upgrade_policy: The upgrade policy. :type upgrade_policy: ~azure.mgmt.compute.v2018_06_01.models.UpgradePolicy :param virtual_machine_profile: The virtual machine profile. :type virtual_machine_profile: ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetVMProfile :ivar provisioning_state: The provisioning state, which only appears in the response. :vartype provisioning_state: str :param overprovision: Specifies whether the Virtual Machine Scale Set should be overprovisioned. :type overprovision: bool :ivar unique_id: Specifies the ID which uniquely identifies a Virtual Machine Scale Set. :vartype unique_id: str :param single_placement_group: When true this limits the scale set to a single placement group, of max size 100 virtual machines. :type single_placement_group: bool :param zone_balance: Whether to force strictly even Virtual Machine distribution cross x-zones in case there is zone outage. :type zone_balance: bool :param platform_fault_domain_count: Fault Domain count for each placement group. :type platform_fault_domain_count: int :param identity: The identity of the virtual machine scale set, if configured. :type identity: ~azure.mgmt.compute.v2018_06_01.models.VirtualMachineScaleSetIdentity :param zones: The virtual machine scale set zones. :type zones: list[str] """ _validation = { 'id': {'readonly': True}, 'name': {'readonly': True}, 'type': {'readonly': True}, 'location': {'required': True}, 'provisioning_state': {'readonly': True}, 'unique_id': {'readonly': True}, } _attribute_map = { 'id': {'key': 'id', 'type': 'str'}, 'name': {'key': 'name', 'type': 'str'}, 'type': {'key': 'type', 'type': 'str'}, 'location': {'key': 'location', 'type': 'str'}, 'tags': {'key': 'tags', 'type': '{str}'}, 'sku': {'key': 'sku', 'type': 'Sku'}, 'plan': {'key': 'plan', 'type': 'Plan'}, 'upgrade_policy': {'key': 'properties.upgradePolicy', 'type': 'UpgradePolicy'}, 'virtual_machine_profile': {'key': 'properties.virtualMachineProfile', 'type': 'VirtualMachineScaleSetVMProfile'}, 'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'}, 'overprovision': {'key': 'properties.overprovision', 'type': 'bool'}, 'unique_id': {'key': 'properties.uniqueId', 'type': 'str'}, 'single_placement_group': {'key': 'properties.singlePlacementGroup', 'type': 'bool'}, 'zone_balance': {'key': 'properties.zoneBalance', 'type': 'bool'}, 'platform_fault_domain_count': {'key': 'properties.platformFaultDomainCount', 'type': 'int'}, 'identity': {'key': 'identity', 'type': 'VirtualMachineScaleSetIdentity'}, 'zones': {'key': 'zones', 'type': '[str]'}, } def __init__(self, *, location: str, tags=None, sku=None, plan=None, upgrade_policy=None, virtual_machine_profile=None, overprovision: bool=None, single_placement_group: bool=None, zone_balance: bool=None, platform_fault_domain_count: int=None, identity=None, zones=None, **kwargs) -> None:
super(VirtualMachineScaleSet, self).__init__(location=location, tags=tags, **kwargs) self.sku = sku self.plan = plan self.upgrade_policy = upgrade_policy self.virtual_machine_profile = virtual_machine_profile self.provisioning_state = None self.overprovision = overprovision self.unique_id = None self.single_placement_group = single_placement_group self.zone_balance = zone_balance self.platform_fault_domain_count = platform_fault_domain_count self.identity = identity self.zones = zones
migrate_v2.go
package cache import ( "context" "io" "os" "time" "github.com/containerd/containerd/content" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/images" "github.com/containerd/containerd/leases" "github.com/containerd/containerd/snapshots" "github.com/moby/buildkit/cache/metadata" "github.com/moby/buildkit/snapshot" "github.com/moby/buildkit/util/bklog" digest "github.com/opencontainers/go-digest" "github.com/pkg/errors" ) func migrateChainID(si *metadata.StorageItem, all map[string]*metadata.StorageItem) (digest.Digest, digest.Digest, error) { diffID := digest.Digest(getDiffID(si)) if diffID == "" { return "", "", nil } blobID := digest.Digest(getBlob(si)) if blobID == "" { return "", "", nil } chainID := digest.Digest(getChainID(si)) blobChainID := digest.Digest(getBlobChainID(si)) if chainID != "" && blobChainID != "" { return chainID, blobChainID, nil } chainID = diffID blobChainID = digest.FromBytes([]byte(blobID + " " + diffID)) parent := getParent(si) if parent != "" { pChainID, pBlobChainID, err := migrateChainID(all[parent], all) if err != nil { return "", "", err } chainID = digest.FromBytes([]byte(pChainID + " " + chainID)) blobChainID = digest.FromBytes([]byte(pBlobChainID + " " + blobChainID)) } queueChainID(si, chainID.String()) queueBlobChainID(si, blobChainID.String()) return chainID, blobChainID, si.Commit() } func MigrateV2(ctx context.Context, from, to string, cs content.Store, s snapshot.Snapshotter, lm leases.Manager) error { _, err := os.Stat(to) if err != nil { if !errors.Is(err, os.ErrNotExist) { return errors.WithStack(err) } } else { return nil } _, err = os.Stat(from) if err != nil { if !errors.Is(err, os.ErrNotExist) { return errors.WithStack(err) } return nil } tmpPath := to + ".tmp" tmpFile, err := os.Create(tmpPath) if err != nil { return errors.WithStack(err) } src, err := os.Open(from) if err != nil { tmpFile.Close() return errors.WithStack(err) } if _, err = io.Copy(tmpFile, src); err != nil { tmpFile.Close() src.Close() return errors.Wrapf(err, "failed to copy db for migration") } src.Close() tmpFile.Close() md, err := metadata.NewStore(tmpPath) if err != nil { return err } items, err := md.All() if err != nil { return err } byID := map[string]*metadata.StorageItem{} for _, item := range items { byID[item.ID()] = item } // add committed, parent, snapshot for id, item := range byID { em := getEqualMutable(item) if em == "" { info, err := s.Stat(ctx, id) if err != nil { return err } if info.Kind == snapshots.KindCommitted { queueCommitted(item) } if info.Parent != "" { queueParent(item, info.Parent) } } else { queueCommitted(item) } queueSnapshotID(item, id) item.Commit() } for _, item := range byID { em := getEqualMutable(item) if em != "" { if getParent(item) == "" { queueParent(item, getParent(byID[em])) item.Commit() } } } type diffPair struct { Blobsum string DiffID string } // move diffID, blobsum to new location for _, item := range byID { v := item.Get("blobmapping.blob") if v == nil { continue } var blob diffPair if err := v.Unmarshal(&blob); err != nil { return errors.WithStack(err) } if _, err := cs.Info(ctx, digest.Digest(blob.Blobsum)); err != nil { continue } queueDiffID(item, blob.DiffID) queueBlob(item, blob.Blobsum) queueMediaType(item, images.MediaTypeDockerSchema2LayerGzip) if err := item.Commit(); err != nil { return err } } // calculate new chainid/blobsumid for _, item := range byID { if _, _, err := migrateChainID(item, byID); err != nil { return err } } ctx = context.TODO() // no cancellation allowed pass this point // add new leases for _, item := range byID { l, err := lm.Create(ctx, func(l *leases.Lease) error { l.ID = item.ID() l.Labels = map[string]string{ "containerd.io/gc.flat": time.Now().UTC().Format(time.RFC3339Nano), } return nil }) if err != nil { // if we are running the migration twice if errors.Is(err, errdefs.ErrAlreadyExists) { continue } return errors.Wrap(err, "failed to create lease") } if err := lm.AddResource(ctx, l, leases.Resource{ ID: getSnapshotID(item), Type: "snapshots/" + s.Name(), }); err != nil {
if blobID := getBlob(item); blobID != "" { if err := lm.AddResource(ctx, l, leases.Resource{ ID: blobID, Type: "content", }); err != nil { return errors.Wrapf(err, "failed to add blob %s to lease", item.ID()) } } } // remove old root labels for _, item := range byID { em := getEqualMutable(item) if em == "" { if _, err := s.Update(ctx, snapshots.Info{ Name: getSnapshotID(item), }, "labels.containerd.io/gc.root"); err != nil { if !errors.Is(err, errdefs.ErrNotFound) { return err } } if blob := getBlob(item); blob != "" { if _, err := cs.Update(ctx, content.Info{ Digest: digest.Digest(blob), }, "labels.containerd.io/gc.root"); err != nil { return err } } } } // previous implementation can leak views, just clean up all views err = s.Walk(ctx, func(ctx context.Context, info snapshots.Info) error { if info.Kind == snapshots.KindView { if _, err := s.Update(ctx, snapshots.Info{ Name: info.Name, }, "labels.containerd.io/gc.root"); err != nil { if !errors.Is(err, errdefs.ErrNotFound) { return err } } } return nil }) if err != nil { return err } // switch to new DB if err := md.Close(); err != nil { return err } if err := os.Rename(tmpPath, to); err != nil { return err } for _, item := range byID { bklog.G(ctx).Infof("migrated %s parent:%q snapshot:%v committed:%v blob:%v diffid:%v chainID:%v blobChainID:%v", item.ID(), getParent(item), getSnapshotID(item), getCommitted(item), getBlob(item), getDiffID(item), getChainID(item), getBlobChainID(item)) } return nil }
return errors.Wrapf(err, "failed to add snapshot %s to lease", item.ID()) }
firewallpolicies.go
package network // Copyright (c) Microsoft and contributors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // // See the License for the specific language governing permissions and // limitations under the License. // // Code generated by Microsoft (R) AutoRest Code Generator. // Changes may cause incorrect behavior and will be lost if the code is regenerated. import ( "context" "github.com/Azure/go-autorest/autorest" "github.com/Azure/go-autorest/autorest/azure" "github.com/Azure/go-autorest/tracing" "net/http" ) // FirewallPoliciesClient is the network Client type FirewallPoliciesClient struct { BaseClient } // NewFirewallPoliciesClient creates an instance of the FirewallPoliciesClient client. func NewFirewallPoliciesClient(subscriptionID string) FirewallPoliciesClient { return NewFirewallPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID) } // NewFirewallPoliciesClientWithBaseURI creates an instance of the FirewallPoliciesClient client using a custom // endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure // stack). func NewFirewallPoliciesClientWithBaseURI(baseURI string, subscriptionID string) FirewallPoliciesClient { return FirewallPoliciesClient{NewWithBaseURI(baseURI, subscriptionID)} } // CreateOrUpdate creates or updates the specified Firewall Policy. // Parameters: // resourceGroupName - the name of the resource group. // firewallPolicyName - the name of the Firewall Policy. // parameters - parameters supplied to the create or update Firewall Policy operation. func (client FirewallPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, firewallPolicyName string, parameters FirewallPolicy) (result FirewallPoliciesCreateOrUpdateFuture, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.CreateOrUpdate") defer func() { sc := -1 if result.Response() != nil { sc = result.Response().StatusCode } tracing.EndSpan(ctx, sc, err) }() } req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, firewallPolicyName, parameters) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request") return } result, err = client.CreateOrUpdateSender(req) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "CreateOrUpdate", result.Response(), "Failure sending request") return } return } // CreateOrUpdatePreparer prepares the CreateOrUpdate request. func (client FirewallPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, firewallPolicyName string, parameters FirewallPolicy) (*http.Request, error) { pathParameters := map[string]interface{}{ "firewallPolicyName": autorest.Encode("path", firewallPolicyName), "resourceGroupName": autorest.Encode("path", resourceGroupName), "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } parameters.Etag = nil preparer := autorest.CreatePreparer( autorest.AsContentType("application/json; charset=utf-8"), autorest.AsPut(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/firewallPolicies/{firewallPolicyName}", pathParameters), autorest.WithJSON(parameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) CreateOrUpdateSender(req *http.Request) (future FirewallPoliciesCreateOrUpdateFuture, err error) { var resp *http.Response resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) if err != nil { return } future.Future, err = azure.NewFutureFromResponse(resp) return } // CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result FirewallPolicy, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), autorest.ByUnmarshallingJSON(&result), autorest.ByClosing()) result.Response = autorest.Response{Response: resp} return } // Delete deletes the specified Firewall Policy. // Parameters: // resourceGroupName - the name of the resource group. // firewallPolicyName - the name of the Firewall Policy. func (client FirewallPoliciesClient) Delete(ctx context.Context, resourceGroupName string, firewallPolicyName string) (result FirewallPoliciesDeleteFuture, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.Delete") defer func() { sc := -1 if result.Response() != nil { sc = result.Response().StatusCode } tracing.EndSpan(ctx, sc, err) }() } req, err := client.DeletePreparer(ctx, resourceGroupName, firewallPolicyName) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "Delete", nil, "Failure preparing request") return } result, err = client.DeleteSender(req) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "Delete", result.Response(), "Failure sending request") return } return } // DeletePreparer prepares the Delete request. func (client FirewallPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, firewallPolicyName string) (*http.Request, error) { pathParameters := map[string]interface{}{ "firewallPolicyName": autorest.Encode("path", firewallPolicyName), "resourceGroupName": autorest.Encode("path", resourceGroupName), "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } preparer := autorest.CreatePreparer( autorest.AsDelete(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/firewallPolicies/{firewallPolicyName}", pathParameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // DeleteSender sends the Delete request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) DeleteSender(req *http.Request) (future FirewallPoliciesDeleteFuture, err error) { var resp *http.Response resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) if err != nil { return } future.Future, err = azure.NewFutureFromResponse(resp) return } // DeleteResponder handles the response to the Delete request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), autorest.ByClosing()) result.Response = resp return } // Get gets the specified Firewall Policy. // Parameters: // resourceGroupName - the name of the resource group. // firewallPolicyName - the name of the Firewall Policy. // expand - expands referenced resources. func (client FirewallPoliciesClient) Get(ctx context.Context, resourceGroupName string, firewallPolicyName string, expand string) (result FirewallPolicy, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.Get") defer func() { sc := -1 if result.Response.Response != nil { sc = result.Response.Response.StatusCode } tracing.EndSpan(ctx, sc, err) }() } req, err := client.GetPreparer(ctx, resourceGroupName, firewallPolicyName, expand) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "Get", nil, "Failure preparing request") return } resp, err := client.GetSender(req) if err != nil { result.Response = autorest.Response{Response: resp} err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "Get", resp, "Failure sending request") return } result, err = client.GetResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "Get", resp, "Failure responding to request") } return } // GetPreparer prepares the Get request. func (client FirewallPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, firewallPolicyName string, expand string) (*http.Request, error) { pathParameters := map[string]interface{}{ "firewallPolicyName": autorest.Encode("path", firewallPolicyName), "resourceGroupName": autorest.Encode("path", resourceGroupName), "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } if len(expand) > 0 { queryParameters["$expand"] = autorest.Encode("query", expand) } preparer := autorest.CreatePreparer( autorest.AsGet(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/firewallPolicies/{firewallPolicyName}", pathParameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // GetSender sends the Get request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { return client.Send(req, azure.DoRetryWithRegistration(client.Client)) } // GetResponder handles the response to the Get request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) GetResponder(resp *http.Response) (result FirewallPolicy, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK), autorest.ByUnmarshallingJSON(&result), autorest.ByClosing()) result.Response = autorest.Response{Response: resp} return } // List lists all Firewall Policies in a resource group. // Parameters: // resourceGroupName - the name of the resource group. func (client FirewallPoliciesClient) List(ctx context.Context, resourceGroupName string) (result FirewallPolicyListResultPage, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.List") defer func() { sc := -1 if result.fplr.Response.Response != nil
tracing.EndSpan(ctx, sc, err) }() } result.fn = client.listNextResults req, err := client.ListPreparer(ctx, resourceGroupName) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "List", nil, "Failure preparing request") return } resp, err := client.ListSender(req) if err != nil { result.fplr.Response = autorest.Response{Response: resp} err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "List", resp, "Failure sending request") return } result.fplr, err = client.ListResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "List", resp, "Failure responding to request") } return } // ListPreparer prepares the List request. func (client FirewallPoliciesClient) ListPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { pathParameters := map[string]interface{}{ "resourceGroupName": autorest.Encode("path", resourceGroupName), "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } preparer := autorest.CreatePreparer( autorest.AsGet(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/firewallPolicies", pathParameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // ListSender sends the List request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) ListSender(req *http.Request) (*http.Response, error) { return client.Send(req, azure.DoRetryWithRegistration(client.Client)) } // ListResponder handles the response to the List request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) ListResponder(resp *http.Response) (result FirewallPolicyListResult, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK), autorest.ByUnmarshallingJSON(&result), autorest.ByClosing()) result.Response = autorest.Response{Response: resp} return } // listNextResults retrieves the next set of results, if any. func (client FirewallPoliciesClient) listNextResults(ctx context.Context, lastResults FirewallPolicyListResult) (result FirewallPolicyListResult, err error) { req, err := lastResults.firewallPolicyListResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listNextResults", nil, "Failure preparing next results request") } if req == nil { return } resp, err := client.ListSender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listNextResults", resp, "Failure sending next results request") } result, err = client.ListResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listNextResults", resp, "Failure responding to next results request") } return } // ListComplete enumerates all values, automatically crossing page boundaries as required. func (client FirewallPoliciesClient) ListComplete(ctx context.Context, resourceGroupName string) (result FirewallPolicyListResultIterator, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.List") defer func() { sc := -1 if result.Response().Response.Response != nil { sc = result.page.Response().Response.Response.StatusCode } tracing.EndSpan(ctx, sc, err) }() } result.page, err = client.List(ctx, resourceGroupName) return } // ListAll gets all the Firewall Policies in a subscription. func (client FirewallPoliciesClient) ListAll(ctx context.Context) (result FirewallPolicyListResultPage, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.ListAll") defer func() { sc := -1 if result.fplr.Response.Response != nil { sc = result.fplr.Response.Response.StatusCode } tracing.EndSpan(ctx, sc, err) }() } result.fn = client.listAllNextResults req, err := client.ListAllPreparer(ctx) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "ListAll", nil, "Failure preparing request") return } resp, err := client.ListAllSender(req) if err != nil { result.fplr.Response = autorest.Response{Response: resp} err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "ListAll", resp, "Failure sending request") return } result.fplr, err = client.ListAllResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "ListAll", resp, "Failure responding to request") } return } // ListAllPreparer prepares the ListAll request. func (client FirewallPoliciesClient) ListAllPreparer(ctx context.Context) (*http.Request, error) { pathParameters := map[string]interface{}{ "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } preparer := autorest.CreatePreparer( autorest.AsGet(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Network/firewallPolicies", pathParameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // ListAllSender sends the ListAll request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) ListAllSender(req *http.Request) (*http.Response, error) { return client.Send(req, azure.DoRetryWithRegistration(client.Client)) } // ListAllResponder handles the response to the ListAll request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) ListAllResponder(resp *http.Response) (result FirewallPolicyListResult, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK), autorest.ByUnmarshallingJSON(&result), autorest.ByClosing()) result.Response = autorest.Response{Response: resp} return } // listAllNextResults retrieves the next set of results, if any. func (client FirewallPoliciesClient) listAllNextResults(ctx context.Context, lastResults FirewallPolicyListResult) (result FirewallPolicyListResult, err error) { req, err := lastResults.firewallPolicyListResultPreparer(ctx) if err != nil { return result, autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listAllNextResults", nil, "Failure preparing next results request") } if req == nil { return } resp, err := client.ListAllSender(req) if err != nil { result.Response = autorest.Response{Response: resp} return result, autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listAllNextResults", resp, "Failure sending next results request") } result, err = client.ListAllResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "listAllNextResults", resp, "Failure responding to next results request") } return } // ListAllComplete enumerates all values, automatically crossing page boundaries as required. func (client FirewallPoliciesClient) ListAllComplete(ctx context.Context) (result FirewallPolicyListResultIterator, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.ListAll") defer func() { sc := -1 if result.Response().Response.Response != nil { sc = result.page.Response().Response.Response.StatusCode } tracing.EndSpan(ctx, sc, err) }() } result.page, err = client.ListAll(ctx) return } // UpdateTags updates a Firewall Policy Tags. // Parameters: // resourceGroupName - the resource group name of the Firewall Policy. // firewallPolicyName - the name of the Firewall Policy being updated. // firewallPolicyParameters - parameters supplied to Update Firewall Policy tags. func (client FirewallPoliciesClient) UpdateTags(ctx context.Context, resourceGroupName string, firewallPolicyName string, firewallPolicyParameters TagsObject) (result FirewallPolicy, err error) { if tracing.IsEnabled() { ctx = tracing.StartSpan(ctx, fqdn+"/FirewallPoliciesClient.UpdateTags") defer func() { sc := -1 if result.Response.Response != nil { sc = result.Response.Response.StatusCode } tracing.EndSpan(ctx, sc, err) }() } req, err := client.UpdateTagsPreparer(ctx, resourceGroupName, firewallPolicyName, firewallPolicyParameters) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "UpdateTags", nil, "Failure preparing request") return } resp, err := client.UpdateTagsSender(req) if err != nil { result.Response = autorest.Response{Response: resp} err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "UpdateTags", resp, "Failure sending request") return } result, err = client.UpdateTagsResponder(resp) if err != nil { err = autorest.NewErrorWithError(err, "network.FirewallPoliciesClient", "UpdateTags", resp, "Failure responding to request") } return } // UpdateTagsPreparer prepares the UpdateTags request. func (client FirewallPoliciesClient) UpdateTagsPreparer(ctx context.Context, resourceGroupName string, firewallPolicyName string, firewallPolicyParameters TagsObject) (*http.Request, error) { pathParameters := map[string]interface{}{ "firewallPolicyName": autorest.Encode("path", firewallPolicyName), "resourceGroupName": autorest.Encode("path", resourceGroupName), "subscriptionId": autorest.Encode("path", client.SubscriptionID), } const APIVersion = "2019-07-01" queryParameters := map[string]interface{}{ "api-version": APIVersion, } preparer := autorest.CreatePreparer( autorest.AsContentType("application/json; charset=utf-8"), autorest.AsPatch(), autorest.WithBaseURL(client.BaseURI), autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/firewallPolicies/{firewallPolicyName}", pathParameters), autorest.WithJSON(firewallPolicyParameters), autorest.WithQueryParameters(queryParameters)) return preparer.Prepare((&http.Request{}).WithContext(ctx)) } // UpdateTagsSender sends the UpdateTags request. The method will close the // http.Response Body if it receives an error. func (client FirewallPoliciesClient) UpdateTagsSender(req *http.Request) (*http.Response, error) { return client.Send(req, azure.DoRetryWithRegistration(client.Client)) } // UpdateTagsResponder handles the response to the UpdateTags request. The method always // closes the http.Response Body. func (client FirewallPoliciesClient) UpdateTagsResponder(resp *http.Response) (result FirewallPolicy, err error) { err = autorest.Respond( resp, azure.WithErrorUnlessStatusCode(http.StatusOK), autorest.ByUnmarshallingJSON(&result), autorest.ByClosing()) result.Response = autorest.Response{Response: resp} return }
{ sc = result.fplr.Response.Response.StatusCode }
local-data.service.ts
import { Injectable, EventEmitter } from '@angular/core'; import { DataService } from './data.service'; import { Observable } from 'rxjs'; import { catchError } from 'rxjs/operators'; import { CompleterItem } from '../model/completer-item'; @Injectable() export class
extends DataService { public dataSourceChange: EventEmitter<void> = new EventEmitter<void>(); protected _data: any[]; constructor() { super(); } public data(data: any[] | Observable<any[]>) { this._data = <any[]>data; this.dataSourceChange.emit(); return this; } public search(term: string): Observable<CompleterItem[]> { return new Observable(subscriber => { if (this._data != null) { const matches: any[] = this.extractMatches(this._data, term); subscriber.next(this.processResults(matches)); subscriber.complete(); } else { subscriber.next([]); subscriber.complete(); } }); } public convertToItem(data: any): CompleterItem { return super.convertToItem(data); } }
LocalDataService
peers.go
package lib import ( "container/list" "errors" "fmt" "log" ) // Container which keeps track of multiple WebRTC remote peers. // Implements |SnowflakeCollector|. // // Maintaining a set of pre-connected Peers with fresh but inactive datachannels // allows allows rapid recovery when the current WebRTC Peer disconnects. // // Note: For now, only one remote can be active at any given moment. // This is a property of Tor circuits & its current multiplexing constraints, // but could be updated if that changes. // (Also, this constraint does not necessarily apply to the more generic PT // version of Snowflake) type Peers struct { Tongue BytesLogger BytesLogger snowflakeChan chan *WebRTCPeer activePeers *list.List capacity int melt chan struct{} } // Construct a fresh container of remote peers. func NewPeers(max int) *Peers { p := &Peers{capacity: max} // Use buffered go channel to pass snowflakes onwards to the SOCKS handler. p.snowflakeChan = make(chan *WebRTCPeer, max) p.activePeers = list.New() p.melt = make(chan struct{}) return p } // As part of |SnowflakeCollector| interface. func (p *Peers) Collect() (*WebRTCPeer, error) { cnt := p.Count() s := fmt.Sprintf("Currently at [%d/%d]", cnt, p.capacity) if cnt >= p.capacity { return nil, fmt.Errorf("At capacity [%d/%d]", cnt, p.capacity) } log.Println("WebRTC: Collecting a new Snowflake.", s) // Engage the Snowflake Catching interface, which must be available. if nil == p.Tongue { return nil, errors.New("missing Tongue to catch Snowflakes with") } // BUG: some broker conflict here. connection, err := p.Tongue.Catch() if nil != err { return nil, err } // Track new valid Snowflake in internal collection and pass along. p.activePeers.PushBack(connection) p.snowflakeChan <- connection return connection, nil } // Pop blocks until an available, valid snowflake appears. Returns nil after End // has been called. func (p *Peers) Pop() *WebRTCPeer { for { snowflake, ok := <-p.snowflakeChan if !ok { return nil } if snowflake.closed { continue } // Set to use the same rate-limited traffic logger to keep consistency. snowflake.BytesLogger = p.BytesLogger return snowflake } } // As part of |SnowflakeCollector| interface. func (p *Peers) Melted() <-chan struct{} { return p.melt } // Returns total available Snowflakes (including the active one) // The count only reduces when connections themselves close, rather than when // they are popped. func (p *Peers) Count() int { p.purgeClosedPeers() return p.activePeers.Len() } func (p *Peers) purgeClosedPeers() { for e := p.activePeers.Front(); e != nil; { next := e.Next() conn := e.Value.(*WebRTCPeer) // Purge those marked for deletion. if conn.closed
e = next } } // Close all Peers contained here. func (p *Peers) End() { close(p.snowflakeChan) close(p.melt) cnt := p.Count() for e := p.activePeers.Front(); e != nil; { next := e.Next() conn := e.Value.(*WebRTCPeer) conn.Close() p.activePeers.Remove(e) e = next } log.Printf("WebRTC: melted all %d snowflakes.", cnt) }
{ p.activePeers.Remove(e) }
index.rs
use std::collections::HashMap; use std::convert::TryFrom; use std::fs; use std::path::PathBuf; use anyhow::{anyhow, bail, Context, Result}; use serde::{Deserialize, Serialize}; use serde_json::Value; use super::cache::Cache; use super::codemodel::Codemodel; use super::toolchains::Toolchains; use super::{Query, Version}; /// CMake tool kind for [`CMake::paths`]. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize)] pub enum PathsKey { #[serde(rename = "cmake")] CMake, #[serde(rename = "ctest")] CTest, #[serde(rename = "cpack")] CPack, #[serde(rename = "root")] Root, } /// The cmake generator used for the build. #[derive(Debug, Clone, PartialEq, Eq, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Generator { /// Whether the generator supports multiple output configurations. pub multi_config: bool, /// The name of the generator. pub name: String, /// If the generator supports `CMAKE_GENERATOR_PLATFORM`, specifies the generator /// platform name. pub platform: Option<String>, } /// Information about the instance of CMake that generated the replies. #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase")] pub struct CMake { pub version: Version, pub paths: HashMap<PathsKey, String>, pub generator: Generator, } /// CMake file API object kind for which cmake should generate information about. #[derive(Debug, PartialEq, Eq, Deserialize, Serialize, Clone, Copy, Hash)] #[serde(rename_all = "camelCase")] pub enum ObjKind { Codemodel, Cache, CmakeFiles, Toolchains, } impl ObjKind { /// Get the supported major version of this object kind. pub(crate) const fn supported_version(self) -> u32 { match self { Self::Codemodel => 2, Self::Cache => 2, Self::CmakeFiles => 1, Self::Toolchains => 1, } } /// Check if `object_version` is supported by this library. pub fn check_version_supported(self, object_version: u32) -> Result<()> { let expected_version = self.supported_version(); if object_version != expected_version { bail!( "cmake {} object version not supported (expected {}, got {})", self.as_str(), expected_version, object_version ); } else { Ok(()) } } /// Get the minimum required cmake version for this object kind. pub fn min_cmake_version(self) -> Version { let (major, minor) = match self { Self::Codemodel => (3, 14), Self::Cache => (3, 14), Self::CmakeFiles => (3, 14), Self::Toolchains => (3, 20), }; Version { major, minor, ..Version::default() } } pub fn as_str(self) -> &'static str { match self { Self::Codemodel => "codemodel", Self::Cache => "cache", Self::CmakeFiles => "cmakeFiles", Self::Toolchains => "toolchains", } } } /// A reply for a specific object kind. #[derive(Debug, Clone, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Reply { /// Path to the JSON file which contains the object. pub json_file: PathBuf, /// The kind of cmake file API object. pub kind: ObjKind, /// The version of the generated object. pub version: Version, } impl Reply { /// Try to load this reply as a codemodel object. pub fn codemodel(&self) -> Result<Codemodel> { Codemodel::try_from(self) } /// Try to load this reply as a cache object. pub fn cache(&self) -> Result<Cache>
/// Try to load this reply as a toolchains object. pub fn toolchains(&self) -> Result<Toolchains> { Toolchains::try_from(self) } } /// Replies generated from a cmake file API query. #[derive(Debug, Clone)] pub struct Replies { /// Information about the instance of CMake that generated the replies. pub cmake: CMake, /// All generated replies. pub replies: HashMap<ObjKind, Reply>, } impl Replies { /// Try to load the cmake file API index from the query and validate. pub fn from_query(query: &Query) -> Result<Replies> { let reply_dir = query.api_dir.join("reply"); let index_file = fs::read_dir(&reply_dir) .context("Failed to list cmake-file-api reply directory")? .filter_map( |file| match (&file, file.as_ref().ok().and_then(|f| f.file_type().ok())) { (Ok(f), Some(file_type)) if file_type.is_file() && f.file_name().to_string_lossy().starts_with("index-") => { Some(f.path()) } _ => None, }, ) .max() .ok_or_else(|| { anyhow!( "No cmake-file-api index file found in '{}' \ (cmake version must be at least 3.14)", reply_dir.display() ) })?; #[derive(Deserialize)] struct Index { cmake: CMake, reply: HashMap<String, Value>, } let base_error = || { anyhow!( "Failed to parse the cmake-file-api index file '{}'", index_file.display() ) }; let Index { cmake, reply } = serde_json::from_reader(&fs::File::open(&index_file)?).with_context(&base_error)?; for kind in query.kinds { let min_cmake_version = kind.min_cmake_version(); if cmake.version.major < min_cmake_version.major || cmake.version.minor < min_cmake_version.minor { bail!( "cmake-file-api {} object not supported: cmake version missmatch, \ expected at least version {}, got version {} instead", kind.as_str(), min_cmake_version, &cmake.version ); } } let client = format!("client-{}", &query.client_name); let (_, reply) = reply .into_iter() .find(|(k, _)| k == &client) .ok_or_else(|| anyhow!("Reply for client '{}' not found", &query.client_name)) .with_context(&base_error)?; #[derive(Deserialize)] #[serde(untagged)] enum ReplyOrError { Reply(Reply), Error { error: String }, } let mut errors = vec![]; let replies: HashMap<ObjKind, Reply> = serde_json::from_value::<HashMap<String, ReplyOrError>>(reply) .with_context(&base_error)? .into_iter() .filter_map(|(_, v)| match v { ReplyOrError::Reply(mut r) => { if let Err(err) = r.kind.check_version_supported(r.version.major) { errors.push(err.to_string()); None } else { r.json_file = reply_dir.join(r.json_file); Some((r.kind, r)) } } ReplyOrError::Error { error } => { errors.push(error); None } }) .collect(); let not_found = query .kinds .iter() .filter(|k| !replies.contains_key(k)) .map(|k| k.as_str()) .collect::<Vec<_>>(); if !not_found.is_empty() { let error = anyhow!( "Objects {} could not be deserialized{}", not_found.join(", "), if errors.is_empty() { String::new() } else { format!(":\n{}", errors.join(",\n")) } ); return Err(error .context(format!( "Could not deserialize all requested objects ({:?})", query.kinds )) .context(base_error())); } else if !errors.is_empty() { log::debug!( "Errors while deserializing cmake-file-api index `{:?}`: {}", index_file, errors.join(",\n") ); } Ok(Replies { cmake, replies }) } /// Get a reply of `kind`. pub fn get_kind(&self, kind: ObjKind) -> Result<&Reply> { self.replies.get(&kind).ok_or_else(|| { anyhow!( "Object {:?} (version {}) not fund in cmake-file-api reply index", kind, kind.supported_version() ) }) } /// Load the codemodel object from a codemodel reply. /// /// Convenience function for `get_kind(ObjKind::Codemodel)?.codemodel()`. pub fn get_codemodel(&self) -> Result<Codemodel> { self.get_kind(ObjKind::Codemodel)?.codemodel() } /// Load the cache object from a cache reply. /// /// Convenience function for `get_kind(ObjKind::Cache)?.cache()`. pub fn get_cache(&self) -> Result<Cache> { self.get_kind(ObjKind::Cache)?.cache() } /// Load the toolchains object from a toolchains reply. /// /// Convenience function for `get_kind(ObjKind::Toolchains)?.toolchains()`. pub fn get_toolchains(&self) -> Result<Toolchains> { self.get_kind(ObjKind::Toolchains)?.toolchains() } }
{ Cache::try_from(self) }
updater.go
// Copyright 2021 The kbrew Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package update import ( "context" "fmt" "os" "os/exec" "path/filepath" "github.com/kbrew-dev/kbrew/pkg/util" "github.com/kbrew-dev/kbrew/pkg/version" "github.com/pkg/errors" ) const ( upgradeCmd = "curl -sfL https://raw.githubusercontent.com/kbrew-dev/kbrew/main/install.sh | sh" ) func getBinDir() (string, error) { path, err := os.Executable() if err != nil { return "", err } return filepath.Dir(path), nil } // IsAvailable checks if a new version of GitHub release available func IsAvailable(ctx context.Context) (string, error) { release, err := util.GetLatestVersion(ctx) if err != nil { return "", errors.Wrap(err, "failed to check for kbrew updates") } if version.Version != *release.TagName
return "", nil } // CheckRelease checks for the latest release func CheckRelease(ctx context.Context) error { release, err := IsAvailable(ctx) if err != nil { return errors.Wrap(err, "failed to check for kbrew updates") } if release == "" { return nil } fmt.Printf("kbrew %s is available, upgrading...\n", release) return upgradeKbrew(ctx) } func upgradeKbrew(ctx context.Context) error { dir, err := getBinDir() if err != nil { return errors.Wrap(err, "failed to get executable dir") } os.Setenv("BINDIR", dir) defer os.Unsetenv("BINDIR") return execCommand(ctx, upgradeCmd) } func execCommand(ctx context.Context, cmd string) error { c := exec.CommandContext(ctx, "sh", "-c", cmd) c.Stdout = os.Stdout c.Stderr = os.Stderr return c.Run() }
{ return *release.TagName, nil }
diffImpl.ts
import MetadataFiles from "../../metadata/metadataFiles"; import * as xml2js from "xml2js"; import * as path from "path"; import * as fs from "fs-extra"; import * as rimraf from "rimraf"; import { SOURCE_EXTENSION_REGEX, MetadataInfo, METADATA_INFO, UNSPLITED_METADATA, PROFILE_PERMISSIONSET_EXTENSION } from "../../metadata/metadataInfo"; import FileUtils from "../../../utils/fileutils"; import * as _ from "lodash"; import ProfileDiff from "./profileDiff"; import PermsetDiff from "./permsetDiff"; import WorkflowDiff from "./workflowDiff"; import SharingRuleDiff from "./sharingRuleDiff"; import CustomLabelsDiff from "./customLabelsDiff"; import DiffUtil, { DiffFile, DiffFileStatus } from "./diffUtil"; import { core } from "@salesforce/command"; import { SFPowerkit, LoggerLevel } from "../../../sfpowerkit"; import { DXProjectManifestUtils } from "../../../utils/dxProjectManifestUtils"; import simplegit from "simple-git/promise"; core.Messages.importMessagesDirectory(__dirname); const messages = core.Messages.loadMessages("sfpowerkit", "project_diff"); const deleteNotSupported = ["RecordType"]; const git = simplegit(); const unsplitedMetadataExtensions = UNSPLITED_METADATA.map(elem => { return elem.sourceExtension; }); const permissionExtensions = PROFILE_PERMISSIONSET_EXTENSION.map(elem => { return elem.sourceExtension; }); export default class DiffImpl { destructivePackageObjPre: any[]; destructivePackageObjPost: any[]; resultOutput: { action: string; metadataType: string; componentName: string; message: string; path: string; }[]; public constructor( private revisionFrom?: string, private revisionTo?: string, private isDestructive?: boolean, private pathToIgnore?: any[] ) { if (this.revisionTo == null || this.revisionTo.trim() === "") { this.revisionTo = "HEAD"; } if (this.revisionFrom == null) { this.revisionFrom = ""; } this.destructivePackageObjPost = new Array(); this.destructivePackageObjPre = new Array(); this.resultOutput = []; } public async build( outputFolder: string, packagedirectories: string[], apiversion: string ) { rimraf.sync(outputFolder); if (packagedirectories) { SFPowerkit.setProjectDirectories(packagedirectories); } if (apiversion) { SFPowerkit.setapiversion(apiversion); } //const sepRegex=/\t| |\n/; const sepRegex = /\n|\r/; let data = ""; //check if same commit const commitFrom = await git.raw([ "rev-list", "-n", "1", this.revisionFrom ]); const commitTo = await git.raw(["rev-list", "-n", "1", this.revisionTo]); if (commitFrom === commitTo) { throw new Error(messages.getMessage("sameCommitErrorMessage")); } //Make it relative to make the command works from a project created as a subfolder in a repository data = await git.diff([ "--raw", this.revisionFrom, this.revisionTo, "--relative" ]); SFPowerkit.log( `Input Param: From: ${this.revisionFrom} To: ${this.revisionTo} `, LoggerLevel.INFO ); SFPowerkit.log( `SHA Found From: ${commitFrom} To: ${commitTo} `, LoggerLevel.INFO ); SFPowerkit.log(data, LoggerLevel.TRACE); let content = data.split(sepRegex); let diffFile: DiffFile = await DiffUtil.parseContent(content); await DiffUtil.fetchFileListRevisionTo(this.revisionTo); let filesToCopy = diffFile.addedEdited; let deletedFiles = diffFile.deleted; deletedFiles = deletedFiles.filter(deleted => { let found = false; let deletedMetadata = MetadataFiles.getFullApiNameWithExtension( deleted.path ); for (let i = 0; i < filesToCopy.length; i++) { let addedOrEdited = MetadataFiles.getFullApiNameWithExtension( filesToCopy[i].path ); if (deletedMetadata === addedOrEdited) { found = true; break; } } return !found; }); if (fs.existsSync(outputFolder) == false) { fs.mkdirSync(outputFolder); } SFPowerkit.log("Files to be copied", LoggerLevel.DEBUG); SFPowerkit.log(filesToCopy, LoggerLevel.DEBUG); if (filesToCopy && filesToCopy.length > 0) { for (var i = 0; i < filesToCopy.length; i++) { let filePath = filesToCopy[i].path; try { if (DiffImpl.checkForIngore(this.pathToIgnore, filePath)) { let matcher = filePath.match(SOURCE_EXTENSION_REGEX); let extension = ""; if (matcher) { extension = matcher[0]; } else { extension = path.parse(filePath).ext; } if (unsplitedMetadataExtensions.includes(extension)) { //handle unsplited files await this.handleUnsplittedMetadata(filesToCopy[i], outputFolder); } else { await DiffUtil.copyFile(filePath, outputFolder); SFPowerkit.log( `Copied file ${filePath} to ${outputFolder}`, LoggerLevel.DEBUG ); } } } catch (ex) { this.resultOutput.push({ action: "ERROR", componentName: "", metadataType: "", message: ex.message, path: filePath }); } } } if (this.isDestructive) { SFPowerkit.log("Creating Destructive Manifest..", LoggerLevel.INFO); await this.createDestructiveChanges(deletedFiles, outputFolder); } SFPowerkit.log(`Generating output summary`, LoggerLevel.INFO); this.buildOutput(outputFolder); if (this.resultOutput.length > 0) { try { await DiffUtil.copyFile(".forceignore", outputFolder); } catch (e) { SFPowerkit.log(`.forceignore not found, skipping..`, LoggerLevel.INFO); } try { //check if package path is provided if (packagedirectories) { let sourceApiVersion = await SFPowerkit.getApiVersion();
path: path }); }); let sfdx_project = { packageDirectories: packageDirectorieslist, namespace: "", sourceApiVersion: sourceApiVersion }; fs.outputFileSync( `${outputFolder}/sfdx-project.json`, JSON.stringify(sfdx_project) ); } else { //Copy project manifest await DiffUtil.copyFile("sfdx-project.json", outputFolder); } //Remove Project Directories that doesnt have any components in ths diff Fix #178 let dxProjectManifestUtils: DXProjectManifestUtils = new DXProjectManifestUtils( outputFolder ); dxProjectManifestUtils.removePackagesNotInDirectory(); } catch (e) { SFPowerkit.log( `sfdx-project.json not found, skipping..`, LoggerLevel.INFO ); } } return this.resultOutput; } private static checkForIngore(pathToIgnore: any[], filePath: string) { pathToIgnore = pathToIgnore || []; if (pathToIgnore.length === 0) { return true; } let returnVal = true; pathToIgnore.forEach(ignore => { if ( path.resolve(ignore) === path.resolve(filePath) || path.resolve(filePath).includes(path.resolve(ignore)) ) { returnVal = false; } }); return returnVal; } private buildOutput(outputFolder) { let metadataFiles = new MetadataFiles(); metadataFiles.loadComponents(outputFolder, false); let keys = Object.keys(METADATA_INFO); let excludedFiles = _.difference( unsplitedMetadataExtensions, permissionExtensions ); keys.forEach(key => { if (METADATA_INFO[key].files && METADATA_INFO[key].files.length > 0) { METADATA_INFO[key].files.forEach(filePath => { let matcher = filePath.match(SOURCE_EXTENSION_REGEX); let extension = ""; if (matcher) { extension = matcher[0]; } else { extension = path.parse(filePath).ext; } if (!excludedFiles.includes(extension)) { let name = FileUtils.getFileNameWithoutExtension( filePath, METADATA_INFO[key].sourceExtension ); if (METADATA_INFO[key].isChildComponent) { let fileParts = filePath.split(path.sep); let parentName = fileParts[fileParts.length - 3]; name = parentName + "." + name; } this.resultOutput.push({ action: "Deploy", metadataType: METADATA_INFO[key].xmlName, componentName: name, message: "", path: filePath }); } }); } }); return this.resultOutput; } private async handleUnsplittedMetadata( diffFile: DiffFileStatus, outputFolder: string ) { let content1 = ""; let content2 = ""; try { if (diffFile.revisionFrom !== "0000000") { content1 = await git.show(["--raw", diffFile.revisionFrom]); } } catch (e) {} try { if (diffFile.revisionTo !== "0000000") { content2 = await git.show(["--raw", diffFile.revisionTo]); } } catch (e) {} FileUtils.mkDirByPathSync( path.join(outputFolder, path.parse(diffFile.path).dir) ); if (diffFile.path.endsWith(METADATA_INFO.Workflow.sourceExtension)) { //Workflow let baseName = path.parse(diffFile.path).base; let objectName = baseName.split(".")[0]; await WorkflowDiff.generateWorkflowXml( content1, content2, path.join(outputFolder, diffFile.path), objectName, this.destructivePackageObjPost, this.resultOutput, this.isDestructive ); } if (diffFile.path.endsWith(METADATA_INFO.SharingRules.sourceExtension)) { let baseName = path.parse(diffFile.path).base; let objectName = baseName.split(".")[0]; await SharingRuleDiff.generateSharingRulesXml( content1, content2, path.join(outputFolder, diffFile.path), objectName, this.destructivePackageObjPost, this.resultOutput, this.isDestructive ); } if (diffFile.path.endsWith(METADATA_INFO.CustomLabels.sourceExtension)) { await CustomLabelsDiff.generateCustomLabelsXml( content1, content2, path.join(outputFolder, diffFile.path), this.destructivePackageObjPost, this.resultOutput, this.isDestructive ); } if (diffFile.path.endsWith(METADATA_INFO.Profile.sourceExtension)) { //Deploy only what changed if (content1 === "") { await DiffUtil.copyFile(diffFile.path, outputFolder); SFPowerkit.log( `Copied file ${diffFile.path} to ${outputFolder}`, LoggerLevel.DEBUG ); } else if (content2 === "") { //The profile is deleted or marked as renamed. //Delete the renamed one let profileType: any = _.find(this.destructivePackageObjPost, function( metaType: any ) { return metaType.name === METADATA_INFO.Profile.xmlName; }); if (profileType === undefined) { profileType = { name: METADATA_INFO.Profile.xmlName, members: [] }; this.destructivePackageObjPost.push(profileType); } let baseName = path.parse(diffFile.path).base; let profileName = baseName.split(".")[0]; profileType.members.push(profileName); } else { await ProfileDiff.generateProfileXml( content1, content2, path.join(outputFolder, diffFile.path) ); } } if (diffFile.path.endsWith(METADATA_INFO.PermissionSet.sourceExtension)) { let sourceApiVersion = await SFPowerkit.getApiVersion(); if (content1 === "") { await DiffUtil.copyFile(diffFile.path, outputFolder); SFPowerkit.log( `Copied file ${diffFile.path} to ${outputFolder}`, LoggerLevel.DEBUG ); } else if (sourceApiVersion <= 39.0) { // in API 39 and erliar PermissionSet deployment are merged. deploy only what changed if (content2 === "") { //Deleted permissionSet let permsetType: any = _.find( this.destructivePackageObjPost, function(metaType: any) { return metaType.name === METADATA_INFO.PermissionSet.xmlName; } ); if (permsetType === undefined) { permsetType = { name: METADATA_INFO.PermissionSet.xmlName, members: [] }; this.destructivePackageObjPost.push(permsetType); } let baseName = path.parse(diffFile.path).base; let permsetName = baseName.split(".")[0]; permsetType.members.push(permsetName); } else { await PermsetDiff.generatePermissionsetXml( content1, content2, path.join(outputFolder, diffFile.path) ); } } else { //PermissionSet deployment override in the target org //So deploy the whole file await DiffUtil.copyFile(diffFile.path, outputFolder); SFPowerkit.log( `Copied file ${diffFile.path} to ${outputFolder}`, LoggerLevel.DEBUG ); } } } private async createDestructiveChanges( filePaths: DiffFileStatus[], outputFolder: string ) { if (_.isNil(this.destructivePackageObjPost)) { this.destructivePackageObjPost = new Array(); } else { this.destructivePackageObjPost = this.destructivePackageObjPost.filter( metaType => { return !_.isNil(metaType.members) && metaType.members.length > 0; } ); } this.destructivePackageObjPre = new Array(); //returns root, dir, base and name for (let i = 0; i < filePaths.length; i++) { let filePath = filePaths[i].path; try { let matcher = filePath.match(SOURCE_EXTENSION_REGEX); let extension = ""; if (matcher) { extension = matcher[0]; } else { extension = path.parse(filePath).ext; } if (unsplitedMetadataExtensions.includes(extension)) { //handle unsplited files await this.handleUnsplittedMetadata(filePaths[i], outputFolder); continue; } let parsedPath = path.parse(filePath); let filename = parsedPath.base; let name = MetadataInfo.getMetadataName(filePath); if (name) { if (!MetadataFiles.isCustomMetadata(filePath, name)) { // avoid to generate destructive for Standard Components //Support on Custom Fields and Custom Objects for now this.resultOutput.push({ action: "Skip", componentName: MetadataFiles.getMemberNameFromFilepath( filePath, name ), metadataType: "StandardField/CustomMetadata", message: "", path: "--" }); continue; } let member = MetadataFiles.getMemberNameFromFilepath(filePath, name); if (name === METADATA_INFO.CustomField.xmlName) { let isFormular = await DiffUtil.isFormulaField(filePaths[i]); if (isFormular) { this.destructivePackageObjPre = this.buildDestructiveTypeObj( this.destructivePackageObjPre, name, member ); SFPowerkit.log( `${filePath} ${MetadataFiles.isCustomMetadata(filePath, name)}`, LoggerLevel.DEBUG ); this.resultOutput.push({ action: "Delete", componentName: member, metadataType: name, message: "", path: "Manual Intervention Required" }); } else { this.destructivePackageObjPost = this.buildDestructiveTypeObj( this.destructivePackageObjPost, name, member ); } SFPowerkit.log( `${filePath} ${MetadataFiles.isCustomMetadata(filePath, name)}`, LoggerLevel.DEBUG ); this.resultOutput.push({ action: "Delete", componentName: member, metadataType: name, message: "", path: "destructiveChanges.xml" }); } else { if (!deleteNotSupported.includes(name)) { this.destructivePackageObjPost = this.buildDestructiveTypeObj( this.destructivePackageObjPost, name, member ); this.resultOutput.push({ action: "Delete", componentName: member, metadataType: name, message: "", path: "destructiveChanges.xml" }); } else { //add the component in the manual action list // TODO } } } } catch (ex) { this.resultOutput.push({ action: "ERROR", componentName: "", metadataType: "", message: ex.message, path: filePath }); } } // this.writeDestructivechanges( // this.destructivePackageObjPre, // outputFolder, // "destructiveChangesPre.xml" // ); this.writeDestructivechanges( this.destructivePackageObjPost, outputFolder, "destructiveChanges.xml" ); } private writeDestructivechanges( destrucObj: Array<any>, outputFolder: string, fileName: string ) { //ensure unique component per type for (let i = 0; i < destrucObj.length; i++) { destrucObj[i].members = _.uniq(destrucObj[i].members); } destrucObj = destrucObj.filter(metaType => { return metaType.members && metaType.members.length > 0; }); if (destrucObj.length > 0) { let dest = { Package: { $: { xmlns: "http://soap.sforce.com/2006/04/metadata" }, types: destrucObj } }; let destructivePackageName = fileName; let filepath = path.join(outputFolder, destructivePackageName); let builder = new xml2js.Builder(); let xml = builder.buildObject(dest); fs.writeFileSync(filepath, xml); } } private buildDestructiveTypeObj(destructiveObj, name, member) { let typeIsPresent: boolean = false; for (let i = 0; i < destructiveObj.length; i++) { if (destructiveObj[i].name === name) { typeIsPresent = true; destructiveObj[i].members.push(member); break; } } let typeNode: any; if (typeIsPresent === false) { typeNode = { name: name, members: [member] }; destructiveObj.push(typeNode); } return destructiveObj; } }
let packageDirectorieslist = []; packagedirectories.forEach(path => { packageDirectorieslist.push({
expr.rs
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ use super::relay; use crate::runtime::String as TString; use crate::runtime::{self, external, IsObject, IsObjectRef, Object, ObjectPtr, ObjectRef}; use crate::DataType; use tvm_macros::Object; #[repr(C)] #[derive(Object)] #[ref_name = "BaseExpr"] #[type_key = "Expr"] pub struct BaseExprNode { pub base: Object, } impl BaseExprNode { pub fn base<T: IsObject>() -> BaseExprNode { BaseExprNode { base: Object::base::<T>(), } } } #[repr(C)] #[derive(Object)] #[ref_name = "PrimExpr"] #[type_key = "PrimExpr"] pub struct PrimExprNode { pub base: BaseExprNode, pub datatype: DataType, } impl PrimExprNode { pub fn base<T: IsObject>(datatype: DataType) -> PrimExprNode { PrimExprNode { base: BaseExprNode::base::<T>(), datatype, } } } #[repr(C)] #[derive(Object)] #[ref_name = "GlobalVar"] #[type_key = "GlobalVar"] pub struct GlobalVarNode { pub base: relay::ExprNode, pub name_hint: TString, } impl GlobalVar { pub fn
(name_hint: String, _span: ObjectRef) -> GlobalVar { let node = GlobalVarNode { base: relay::ExprNode::base::<GlobalVarNode>(), name_hint: name_hint.into(), }; GlobalVar(Some(ObjectPtr::new(node))) } } // TODO(@jroesch): update to match TVM // Move IntImm // Define FloatImm // Define Bool // Define tvm::Integer? // Define RangeNode // TODO: figure out how to type the last argument runtime::TypedPackedFunc<String(ObjectRef)> annotate) external! { #[name("ir.AsText")] fn _as_text(object: ObjectRef, show_meta_data: i32, annotate: runtime::Function) -> TString; } pub fn as_text<T: IsObjectRef>(object: T) -> String { let no_func = unsafe { runtime::Function::null() }; _as_text(object.upcast(), 0, no_func) .unwrap() .as_str() .unwrap() .into() }
new
index.js
const path = require('path'); const fsPromises = require('fs/promises'); //пути для копирования const sourceFolderPath = path.join(__dirname, 'files'); const destinationFolderPath = path.join(__dirname, 'files-copy'); //промисы нужны для того, чтобы не было "конкуренции" //(когда файл копируется и асинхронно его пытаются удалить) async function copyAll() { try { //создаём папку await fsPromises.mkdir(destinationFolderPath, {recursive: true}); const destinationFiles = await fsPromises.readdir(destinationFolderPath); //удаляем файлы из папки, если они есть for (const destinationFile of destinationFiles) { let curPath = path.join(destinationFolderPath, destinationFile); await fsPromises.unlink(curPath); } //читаем папку сырцов const sourceFiles = await fsPromises.readdir(sourceFolderPath, {withFileTypes: true}); //копируем файлы for (const sourceFile of sourceFiles) { let sourceFilePath = path.join(sourceFolderPath, sourceFile.name); let destinationFilePath = path.join(destinationFolderPath, sourceFile.name); await fsPromises.copyFile(sourceFilePath, destinationFilePath); } } catch (err) { console.error(err); } }
copyAll().then(() => console.log('Files copy successfully'));
grammar.rs
#[derive(Debug,Clone,PartialEq)] pub enum AddOp { Add, Subtract, Start, } #[derive(Debug,Clone,PartialEq)] pub enum MultOp { Multiply, Divide, Modulo, Start, } #[derive(Clone,Debug,PartialEq)] pub struct AddTerm(pub AddOp, pub Expr); #[derive(Clone,Debug,PartialEq)] pub struct MultTerm(pub MultOp, pub Expr); #[derive(Debug,Clone,PartialEq)] pub enum Expr { Variable(String), Num(i32), AddSub(Vec<AddTerm>), // a + b - c + d becomes [(+ a) (+ b) (- c) (+ d)] MultDiv(Vec<MultTerm>), } // for now this is it's own type and not a statement #[derive(Debug,Clone,PartialEq)] pub struct Block(pub Vec<Statement>); #[derive(Debug,Clone,PartialEq)] pub enum Statement { Assign(String, Expr), Output(Expr), If(Expr, Comparator, Expr, Block, Option<Block>), While(Expr, Comparator, Expr, Block), Loop(Expr, Block), } #[derive(Debug, Copy, Clone, Eq, PartialEq)] pub enum Comparator { Eq, // == Gt, // > Lt, // < Neq, // != Geq, // >= Leq, // <= } use std::ops::Not; impl Not for Comparator{ type Output = Self; fn not(self) -> Self::Output
}
{ use self::Comparator::*; match self { Eq => Neq, Gt => Leq, Lt => Geq, Neq => Eq, Geq => Lt, Leq => Gt, } }
lightning.pb.go
// Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.26.0 // protoc v3.6.1 // source: lightning.proto package lnrpc import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" ) const ( // Verify that this generated code is sufficiently up-to-date. _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) // Verify that runtime/protoimpl is sufficiently up-to-date. _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) // //`AddressType` has to be one of: // //- `p2wkh`: Pay to witness key hash (`WITNESS_PUBKEY_HASH` = 0) //- `np2wkh`: Pay to nested witness key hash (`NESTED_PUBKEY_HASH` = 1) type AddressType int32 const ( AddressType_WITNESS_PUBKEY_HASH AddressType = 0 AddressType_NESTED_PUBKEY_HASH AddressType = 1 AddressType_UNUSED_WITNESS_PUBKEY_HASH AddressType = 2 AddressType_UNUSED_NESTED_PUBKEY_HASH AddressType = 3 ) // Enum value maps for AddressType. var ( AddressType_name = map[int32]string{ 0: "WITNESS_PUBKEY_HASH", 1: "NESTED_PUBKEY_HASH", 2: "UNUSED_WITNESS_PUBKEY_HASH", 3: "UNUSED_NESTED_PUBKEY_HASH", } AddressType_value = map[string]int32{ "WITNESS_PUBKEY_HASH": 0, "NESTED_PUBKEY_HASH": 1, "UNUSED_WITNESS_PUBKEY_HASH": 2, "UNUSED_NESTED_PUBKEY_HASH": 3, } ) func (x AddressType) Enum() *AddressType { p := new(AddressType) *p = x return p } func (x AddressType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (AddressType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[0].Descriptor() } func (AddressType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[0] } func (x AddressType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use AddressType.Descriptor instead. func (AddressType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{0} } type CommitmentType int32 const ( // //Returned when the commitment type isn't known or unavailable. CommitmentType_UNKNOWN_COMMITMENT_TYPE CommitmentType = 0 // //A channel using the legacy commitment format having tweaked to_remote //keys. CommitmentType_LEGACY CommitmentType = 1 // //A channel that uses the modern commitment format where the key in the //output of the remote party does not change each state. This makes back //up and recovery easier as when the channel is closed, the funds go //directly to that key. CommitmentType_STATIC_REMOTE_KEY CommitmentType = 2 // //A channel that uses a commitment format that has anchor outputs on the //commitments, allowing fee bumping after a force close transaction has //been broadcast. CommitmentType_ANCHORS CommitmentType = 3 // //A channel that uses a commitment type that builds upon the anchors //commitment format, but in addition requires a CLTV clause to spend outputs //paying to the channel initiator. This is intended for use on leased channels //to guarantee that the channel initiator has no incentives to close a leased //channel before its maturity date. CommitmentType_SCRIPT_ENFORCED_LEASE CommitmentType = 4 ) // Enum value maps for CommitmentType. var ( CommitmentType_name = map[int32]string{ 0: "UNKNOWN_COMMITMENT_TYPE", 1: "LEGACY", 2: "STATIC_REMOTE_KEY", 3: "ANCHORS", 4: "SCRIPT_ENFORCED_LEASE", } CommitmentType_value = map[string]int32{ "UNKNOWN_COMMITMENT_TYPE": 0, "LEGACY": 1, "STATIC_REMOTE_KEY": 2, "ANCHORS": 3, "SCRIPT_ENFORCED_LEASE": 4, } ) func (x CommitmentType) Enum() *CommitmentType { p := new(CommitmentType) *p = x return p } func (x CommitmentType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (CommitmentType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[1].Descriptor() } func (CommitmentType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[1] } func (x CommitmentType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use CommitmentType.Descriptor instead. func (CommitmentType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{1} } type Initiator int32 const ( Initiator_INITIATOR_UNKNOWN Initiator = 0 Initiator_INITIATOR_LOCAL Initiator = 1 Initiator_INITIATOR_REMOTE Initiator = 2 Initiator_INITIATOR_BOTH Initiator = 3 ) // Enum value maps for Initiator. var ( Initiator_name = map[int32]string{ 0: "INITIATOR_UNKNOWN", 1: "INITIATOR_LOCAL", 2: "INITIATOR_REMOTE", 3: "INITIATOR_BOTH", } Initiator_value = map[string]int32{ "INITIATOR_UNKNOWN": 0, "INITIATOR_LOCAL": 1, "INITIATOR_REMOTE": 2, "INITIATOR_BOTH": 3, } ) func (x Initiator) Enum() *Initiator { p := new(Initiator) *p = x return p } func (x Initiator) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (Initiator) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[2].Descriptor() } func (Initiator) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[2] } func (x Initiator) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use Initiator.Descriptor instead. func (Initiator) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{2} } type ResolutionType int32 const ( ResolutionType_TYPE_UNKNOWN ResolutionType = 0 // We resolved an anchor output. ResolutionType_ANCHOR ResolutionType = 1 // //We are resolving an incoming htlc on chain. This if this htlc is //claimed, we swept the incoming htlc with the preimage. If it is timed //out, our peer swept the timeout path. ResolutionType_INCOMING_HTLC ResolutionType = 2 // //We are resolving an outgoing htlc on chain. If this htlc is claimed, //the remote party swept the htlc with the preimage. If it is timed out, //we swept it with the timeout path. ResolutionType_OUTGOING_HTLC ResolutionType = 3 // We force closed and need to sweep our time locked commitment output. ResolutionType_COMMIT ResolutionType = 4 ) // Enum value maps for ResolutionType. var ( ResolutionType_name = map[int32]string{ 0: "TYPE_UNKNOWN", 1: "ANCHOR", 2: "INCOMING_HTLC", 3: "OUTGOING_HTLC", 4: "COMMIT", } ResolutionType_value = map[string]int32{ "TYPE_UNKNOWN": 0, "ANCHOR": 1, "INCOMING_HTLC": 2, "OUTGOING_HTLC": 3, "COMMIT": 4, } ) func (x ResolutionType) Enum() *ResolutionType { p := new(ResolutionType) *p = x return p } func (x ResolutionType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (ResolutionType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[3].Descriptor() } func (ResolutionType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[3] } func (x ResolutionType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use ResolutionType.Descriptor instead. func (ResolutionType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{3} } type ResolutionOutcome int32 const ( // Outcome unknown. ResolutionOutcome_OUTCOME_UNKNOWN ResolutionOutcome = 0 // An output was claimed on chain. ResolutionOutcome_CLAIMED ResolutionOutcome = 1 // An output was left unclaimed on chain. ResolutionOutcome_UNCLAIMED ResolutionOutcome = 2 // //ResolverOutcomeAbandoned indicates that an output that we did not //claim on chain, for example an anchor that we did not sweep and a //third party claimed on chain, or a htlc that we could not decode //so left unclaimed. ResolutionOutcome_ABANDONED ResolutionOutcome = 3 // //If we force closed our channel, our htlcs need to be claimed in two //stages. This outcome represents the broadcast of a timeout or success //transaction for this two stage htlc claim. ResolutionOutcome_FIRST_STAGE ResolutionOutcome = 4 // A htlc was timed out on chain. ResolutionOutcome_TIMEOUT ResolutionOutcome = 5 ) // Enum value maps for ResolutionOutcome. var ( ResolutionOutcome_name = map[int32]string{ 0: "OUTCOME_UNKNOWN", 1: "CLAIMED", 2: "UNCLAIMED", 3: "ABANDONED", 4: "FIRST_STAGE", 5: "TIMEOUT", } ResolutionOutcome_value = map[string]int32{ "OUTCOME_UNKNOWN": 0, "CLAIMED": 1, "UNCLAIMED": 2, "ABANDONED": 3, "FIRST_STAGE": 4, "TIMEOUT": 5, } ) func (x ResolutionOutcome) Enum() *ResolutionOutcome { p := new(ResolutionOutcome) *p = x return p } func (x ResolutionOutcome) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (ResolutionOutcome) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[4].Descriptor() } func (ResolutionOutcome) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[4] } func (x ResolutionOutcome) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use ResolutionOutcome.Descriptor instead. func (ResolutionOutcome) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{4} } type NodeMetricType int32 const ( NodeMetricType_UNKNOWN NodeMetricType = 0 NodeMetricType_BETWEENNESS_CENTRALITY NodeMetricType = 1 ) // Enum value maps for NodeMetricType. var ( NodeMetricType_name = map[int32]string{ 0: "UNKNOWN", 1: "BETWEENNESS_CENTRALITY", } NodeMetricType_value = map[string]int32{ "UNKNOWN": 0, "BETWEENNESS_CENTRALITY": 1, } ) func (x NodeMetricType) Enum() *NodeMetricType { p := new(NodeMetricType) *p = x return p } func (x NodeMetricType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (NodeMetricType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[5].Descriptor() } func (NodeMetricType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[5] } func (x NodeMetricType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use NodeMetricType.Descriptor instead. func (NodeMetricType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{5} } type InvoiceHTLCState int32 const ( InvoiceHTLCState_ACCEPTED InvoiceHTLCState = 0 InvoiceHTLCState_SETTLED InvoiceHTLCState = 1 InvoiceHTLCState_CANCELED InvoiceHTLCState = 2 ) // Enum value maps for InvoiceHTLCState. var ( InvoiceHTLCState_name = map[int32]string{ 0: "ACCEPTED", 1: "SETTLED", 2: "CANCELED", } InvoiceHTLCState_value = map[string]int32{ "ACCEPTED": 0, "SETTLED": 1, "CANCELED": 2, } ) func (x InvoiceHTLCState) Enum() *InvoiceHTLCState { p := new(InvoiceHTLCState) *p = x return p } func (x InvoiceHTLCState) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (InvoiceHTLCState) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[6].Descriptor() } func (InvoiceHTLCState) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[6] } func (x InvoiceHTLCState) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use InvoiceHTLCState.Descriptor instead. func (InvoiceHTLCState) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{6} } type PaymentFailureReason int32 const ( // //Payment isn't failed (yet). PaymentFailureReason_FAILURE_REASON_NONE PaymentFailureReason = 0 // //There are more routes to try, but the payment timeout was exceeded. PaymentFailureReason_FAILURE_REASON_TIMEOUT PaymentFailureReason = 1 // //All possible routes were tried and failed permanently. Or were no //routes to the destination at all. PaymentFailureReason_FAILURE_REASON_NO_ROUTE PaymentFailureReason = 2 // //A non-recoverable error has occured. PaymentFailureReason_FAILURE_REASON_ERROR PaymentFailureReason = 3 // //Payment details incorrect (unknown hash, invalid amt or //invalid final cltv delta) PaymentFailureReason_FAILURE_REASON_INCORRECT_PAYMENT_DETAILS PaymentFailureReason = 4 // //Insufficient local balance. PaymentFailureReason_FAILURE_REASON_INSUFFICIENT_BALANCE PaymentFailureReason = 5 ) // Enum value maps for PaymentFailureReason. var ( PaymentFailureReason_name = map[int32]string{ 0: "FAILURE_REASON_NONE", 1: "FAILURE_REASON_TIMEOUT", 2: "FAILURE_REASON_NO_ROUTE", 3: "FAILURE_REASON_ERROR", 4: "FAILURE_REASON_INCORRECT_PAYMENT_DETAILS", 5: "FAILURE_REASON_INSUFFICIENT_BALANCE", } PaymentFailureReason_value = map[string]int32{ "FAILURE_REASON_NONE": 0, "FAILURE_REASON_TIMEOUT": 1, "FAILURE_REASON_NO_ROUTE": 2, "FAILURE_REASON_ERROR": 3, "FAILURE_REASON_INCORRECT_PAYMENT_DETAILS": 4, "FAILURE_REASON_INSUFFICIENT_BALANCE": 5, } ) func (x PaymentFailureReason) Enum() *PaymentFailureReason { p := new(PaymentFailureReason) *p = x return p } func (x PaymentFailureReason) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (PaymentFailureReason) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[7].Descriptor() } func (PaymentFailureReason) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[7] } func (x PaymentFailureReason) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use PaymentFailureReason.Descriptor instead. func (PaymentFailureReason) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{7} } type FeatureBit int32 const ( FeatureBit_DATALOSS_PROTECT_REQ FeatureBit = 0 FeatureBit_DATALOSS_PROTECT_OPT FeatureBit = 1 FeatureBit_INITIAL_ROUING_SYNC FeatureBit = 3 FeatureBit_UPFRONT_SHUTDOWN_SCRIPT_REQ FeatureBit = 4 FeatureBit_UPFRONT_SHUTDOWN_SCRIPT_OPT FeatureBit = 5 FeatureBit_GOSSIP_QUERIES_REQ FeatureBit = 6 FeatureBit_GOSSIP_QUERIES_OPT FeatureBit = 7 FeatureBit_TLV_ONION_REQ FeatureBit = 8 FeatureBit_TLV_ONION_OPT FeatureBit = 9 FeatureBit_EXT_GOSSIP_QUERIES_REQ FeatureBit = 10 FeatureBit_EXT_GOSSIP_QUERIES_OPT FeatureBit = 11 FeatureBit_STATIC_REMOTE_KEY_REQ FeatureBit = 12 FeatureBit_STATIC_REMOTE_KEY_OPT FeatureBit = 13 FeatureBit_PAYMENT_ADDR_REQ FeatureBit = 14 FeatureBit_PAYMENT_ADDR_OPT FeatureBit = 15 FeatureBit_MPP_REQ FeatureBit = 16 FeatureBit_MPP_OPT FeatureBit = 17 FeatureBit_WUMBO_CHANNELS_REQ FeatureBit = 18 FeatureBit_WUMBO_CHANNELS_OPT FeatureBit = 19 FeatureBit_ANCHORS_REQ FeatureBit = 20 FeatureBit_ANCHORS_OPT FeatureBit = 21 FeatureBit_ANCHORS_ZERO_FEE_HTLC_REQ FeatureBit = 22 FeatureBit_ANCHORS_ZERO_FEE_HTLC_OPT FeatureBit = 23 FeatureBit_AMP_REQ FeatureBit = 30 FeatureBit_AMP_OPT FeatureBit = 31 ) // Enum value maps for FeatureBit. var ( FeatureBit_name = map[int32]string{ 0: "DATALOSS_PROTECT_REQ", 1: "DATALOSS_PROTECT_OPT", 3: "INITIAL_ROUING_SYNC", 4: "UPFRONT_SHUTDOWN_SCRIPT_REQ", 5: "UPFRONT_SHUTDOWN_SCRIPT_OPT", 6: "GOSSIP_QUERIES_REQ", 7: "GOSSIP_QUERIES_OPT", 8: "TLV_ONION_REQ", 9: "TLV_ONION_OPT", 10: "EXT_GOSSIP_QUERIES_REQ", 11: "EXT_GOSSIP_QUERIES_OPT", 12: "STATIC_REMOTE_KEY_REQ", 13: "STATIC_REMOTE_KEY_OPT", 14: "PAYMENT_ADDR_REQ", 15: "PAYMENT_ADDR_OPT", 16: "MPP_REQ", 17: "MPP_OPT", 18: "WUMBO_CHANNELS_REQ", 19: "WUMBO_CHANNELS_OPT", 20: "ANCHORS_REQ", 21: "ANCHORS_OPT", 22: "ANCHORS_ZERO_FEE_HTLC_REQ", 23: "ANCHORS_ZERO_FEE_HTLC_OPT", 30: "AMP_REQ", 31: "AMP_OPT", } FeatureBit_value = map[string]int32{ "DATALOSS_PROTECT_REQ": 0, "DATALOSS_PROTECT_OPT": 1, "INITIAL_ROUING_SYNC": 3, "UPFRONT_SHUTDOWN_SCRIPT_REQ": 4, "UPFRONT_SHUTDOWN_SCRIPT_OPT": 5, "GOSSIP_QUERIES_REQ": 6, "GOSSIP_QUERIES_OPT": 7, "TLV_ONION_REQ": 8, "TLV_ONION_OPT": 9, "EXT_GOSSIP_QUERIES_REQ": 10, "EXT_GOSSIP_QUERIES_OPT": 11, "STATIC_REMOTE_KEY_REQ": 12, "STATIC_REMOTE_KEY_OPT": 13, "PAYMENT_ADDR_REQ": 14, "PAYMENT_ADDR_OPT": 15, "MPP_REQ": 16, "MPP_OPT": 17, "WUMBO_CHANNELS_REQ": 18, "WUMBO_CHANNELS_OPT": 19, "ANCHORS_REQ": 20, "ANCHORS_OPT": 21, "ANCHORS_ZERO_FEE_HTLC_REQ": 22, "ANCHORS_ZERO_FEE_HTLC_OPT": 23, "AMP_REQ": 30, "AMP_OPT": 31, } ) func (x FeatureBit) Enum() *FeatureBit { p := new(FeatureBit) *p = x return p } func (x FeatureBit) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (FeatureBit) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[8].Descriptor() } func (FeatureBit) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[8] } func (x FeatureBit) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use FeatureBit.Descriptor instead. func (FeatureBit) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{8} } type UpdateFailure int32 const ( UpdateFailure_UPDATE_FAILURE_UNKNOWN UpdateFailure = 0 UpdateFailure_UPDATE_FAILURE_PENDING UpdateFailure = 1 UpdateFailure_UPDATE_FAILURE_NOT_FOUND UpdateFailure = 2 UpdateFailure_UPDATE_FAILURE_INTERNAL_ERR UpdateFailure = 3 UpdateFailure_UPDATE_FAILURE_INVALID_PARAMETER UpdateFailure = 4 ) // Enum value maps for UpdateFailure. var ( UpdateFailure_name = map[int32]string{ 0: "UPDATE_FAILURE_UNKNOWN", 1: "UPDATE_FAILURE_PENDING", 2: "UPDATE_FAILURE_NOT_FOUND", 3: "UPDATE_FAILURE_INTERNAL_ERR", 4: "UPDATE_FAILURE_INVALID_PARAMETER", } UpdateFailure_value = map[string]int32{ "UPDATE_FAILURE_UNKNOWN": 0, "UPDATE_FAILURE_PENDING": 1, "UPDATE_FAILURE_NOT_FOUND": 2, "UPDATE_FAILURE_INTERNAL_ERR": 3, "UPDATE_FAILURE_INVALID_PARAMETER": 4, } ) func (x UpdateFailure) Enum() *UpdateFailure { p := new(UpdateFailure) *p = x return p } func (x UpdateFailure) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (UpdateFailure) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[9].Descriptor() } func (UpdateFailure) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[9] } func (x UpdateFailure) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use UpdateFailure.Descriptor instead. func (UpdateFailure) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{9} } type ChannelCloseSummary_ClosureType int32 const ( ChannelCloseSummary_COOPERATIVE_CLOSE ChannelCloseSummary_ClosureType = 0 ChannelCloseSummary_LOCAL_FORCE_CLOSE ChannelCloseSummary_ClosureType = 1 ChannelCloseSummary_REMOTE_FORCE_CLOSE ChannelCloseSummary_ClosureType = 2 ChannelCloseSummary_BREACH_CLOSE ChannelCloseSummary_ClosureType = 3 ChannelCloseSummary_FUNDING_CANCELED ChannelCloseSummary_ClosureType = 4 ChannelCloseSummary_ABANDONED ChannelCloseSummary_ClosureType = 5 ) // Enum value maps for ChannelCloseSummary_ClosureType. var ( ChannelCloseSummary_ClosureType_name = map[int32]string{ 0: "COOPERATIVE_CLOSE", 1: "LOCAL_FORCE_CLOSE", 2: "REMOTE_FORCE_CLOSE", 3: "BREACH_CLOSE", 4: "FUNDING_CANCELED", 5: "ABANDONED", } ChannelCloseSummary_ClosureType_value = map[string]int32{ "COOPERATIVE_CLOSE": 0, "LOCAL_FORCE_CLOSE": 1, "REMOTE_FORCE_CLOSE": 2, "BREACH_CLOSE": 3, "FUNDING_CANCELED": 4, "ABANDONED": 5, } ) func (x ChannelCloseSummary_ClosureType) Enum() *ChannelCloseSummary_ClosureType { p := new(ChannelCloseSummary_ClosureType) *p = x return p } func (x ChannelCloseSummary_ClosureType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (ChannelCloseSummary_ClosureType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[10].Descriptor() } func (ChannelCloseSummary_ClosureType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[10] } func (x ChannelCloseSummary_ClosureType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use ChannelCloseSummary_ClosureType.Descriptor instead. func (ChannelCloseSummary_ClosureType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{40, 0} } type Peer_SyncType int32 const ( // //Denotes that we cannot determine the peer's current sync type. Peer_UNKNOWN_SYNC Peer_SyncType = 0 // //Denotes that we are actively receiving new graph updates from the peer. Peer_ACTIVE_SYNC Peer_SyncType = 1 // //Denotes that we are not receiving new graph updates from the peer. Peer_PASSIVE_SYNC Peer_SyncType = 2 // //Denotes that this peer is pinned into an active sync. Peer_PINNED_SYNC Peer_SyncType = 3 ) // Enum value maps for Peer_SyncType. var ( Peer_SyncType_name = map[int32]string{ 0: "UNKNOWN_SYNC", 1: "ACTIVE_SYNC", 2: "PASSIVE_SYNC", 3: "PINNED_SYNC", } Peer_SyncType_value = map[string]int32{ "UNKNOWN_SYNC": 0, "ACTIVE_SYNC": 1, "PASSIVE_SYNC": 2, "PINNED_SYNC": 3, } ) func (x Peer_SyncType) Enum() *Peer_SyncType { p := new(Peer_SyncType) *p = x return p } func (x Peer_SyncType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (Peer_SyncType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[11].Descriptor() } func (Peer_SyncType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[11] } func (x Peer_SyncType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use Peer_SyncType.Descriptor instead. func (Peer_SyncType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{44, 0} } type PeerEvent_EventType int32 const ( PeerEvent_PEER_ONLINE PeerEvent_EventType = 0 PeerEvent_PEER_OFFLINE PeerEvent_EventType = 1 ) // Enum value maps for PeerEvent_EventType. var ( PeerEvent_EventType_name = map[int32]string{ 0: "PEER_ONLINE", 1: "PEER_OFFLINE", } PeerEvent_EventType_value = map[string]int32{ "PEER_ONLINE": 0, "PEER_OFFLINE": 1, } ) func (x PeerEvent_EventType) Enum() *PeerEvent_EventType { p := new(PeerEvent_EventType) *p = x return p } func (x PeerEvent_EventType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (PeerEvent_EventType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[12].Descriptor() } func (PeerEvent_EventType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[12] } func (x PeerEvent_EventType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use PeerEvent_EventType.Descriptor instead. func (PeerEvent_EventType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{49, 0} } type PendingChannelsResponse_ForceClosedChannel_AnchorState int32 const ( PendingChannelsResponse_ForceClosedChannel_LIMBO PendingChannelsResponse_ForceClosedChannel_AnchorState = 0 PendingChannelsResponse_ForceClosedChannel_RECOVERED PendingChannelsResponse_ForceClosedChannel_AnchorState = 1 PendingChannelsResponse_ForceClosedChannel_LOST PendingChannelsResponse_ForceClosedChannel_AnchorState = 2 ) // Enum value maps for PendingChannelsResponse_ForceClosedChannel_AnchorState. var ( PendingChannelsResponse_ForceClosedChannel_AnchorState_name = map[int32]string{ 0: "LIMBO", 1: "RECOVERED", 2: "LOST", } PendingChannelsResponse_ForceClosedChannel_AnchorState_value = map[string]int32{ "LIMBO": 0, "RECOVERED": 1, "LOST": 2, } ) func (x PendingChannelsResponse_ForceClosedChannel_AnchorState) Enum() *PendingChannelsResponse_ForceClosedChannel_AnchorState { p := new(PendingChannelsResponse_ForceClosedChannel_AnchorState) *p = x return p } func (x PendingChannelsResponse_ForceClosedChannel_AnchorState) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (PendingChannelsResponse_ForceClosedChannel_AnchorState) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[13].Descriptor() } func (PendingChannelsResponse_ForceClosedChannel_AnchorState) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[13] } func (x PendingChannelsResponse_ForceClosedChannel_AnchorState) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use PendingChannelsResponse_ForceClosedChannel_AnchorState.Descriptor instead. func (PendingChannelsResponse_ForceClosedChannel_AnchorState) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 5, 0} } type ChannelEventUpdate_UpdateType int32 const ( ChannelEventUpdate_OPEN_CHANNEL ChannelEventUpdate_UpdateType = 0 ChannelEventUpdate_CLOSED_CHANNEL ChannelEventUpdate_UpdateType = 1 ChannelEventUpdate_ACTIVE_CHANNEL ChannelEventUpdate_UpdateType = 2 ChannelEventUpdate_INACTIVE_CHANNEL ChannelEventUpdate_UpdateType = 3 ChannelEventUpdate_PENDING_OPEN_CHANNEL ChannelEventUpdate_UpdateType = 4 ChannelEventUpdate_FULLY_RESOLVED_CHANNEL ChannelEventUpdate_UpdateType = 5 ) // Enum value maps for ChannelEventUpdate_UpdateType. var ( ChannelEventUpdate_UpdateType_name = map[int32]string{ 0: "OPEN_CHANNEL", 1: "CLOSED_CHANNEL", 2: "ACTIVE_CHANNEL", 3: "INACTIVE_CHANNEL", 4: "PENDING_OPEN_CHANNEL", 5: "FULLY_RESOLVED_CHANNEL", } ChannelEventUpdate_UpdateType_value = map[string]int32{ "OPEN_CHANNEL": 0, "CLOSED_CHANNEL": 1, "ACTIVE_CHANNEL": 2, "INACTIVE_CHANNEL": 3, "PENDING_OPEN_CHANNEL": 4, "FULLY_RESOLVED_CHANNEL": 5, } ) func (x ChannelEventUpdate_UpdateType) Enum() *ChannelEventUpdate_UpdateType { p := new(ChannelEventUpdate_UpdateType) *p = x return p } func (x ChannelEventUpdate_UpdateType) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (ChannelEventUpdate_UpdateType) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[14].Descriptor() } func (ChannelEventUpdate_UpdateType) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[14] } func (x ChannelEventUpdate_UpdateType) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use ChannelEventUpdate_UpdateType.Descriptor instead. func (ChannelEventUpdate_UpdateType) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{81, 0} } type Invoice_InvoiceState int32 const ( Invoice_OPEN Invoice_InvoiceState = 0 Invoice_SETTLED Invoice_InvoiceState = 1 Invoice_CANCELED Invoice_InvoiceState = 2 Invoice_ACCEPTED Invoice_InvoiceState = 3 ) // Enum value maps for Invoice_InvoiceState. var ( Invoice_InvoiceState_name = map[int32]string{ 0: "OPEN", 1: "SETTLED", 2: "CANCELED", 3: "ACCEPTED", } Invoice_InvoiceState_value = map[string]int32{ "OPEN": 0, "SETTLED": 1, "CANCELED": 2, "ACCEPTED": 3, } ) func (x Invoice_InvoiceState) Enum() *Invoice_InvoiceState { p := new(Invoice_InvoiceState) *p = x return p } func (x Invoice_InvoiceState) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (Invoice_InvoiceState) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[15].Descriptor() } func (Invoice_InvoiceState) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[15] } func (x Invoice_InvoiceState) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use Invoice_InvoiceState.Descriptor instead. func (Invoice_InvoiceState) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{121, 0} } type Payment_PaymentStatus int32 const ( Payment_UNKNOWN Payment_PaymentStatus = 0 Payment_IN_FLIGHT Payment_PaymentStatus = 1 Payment_SUCCEEDED Payment_PaymentStatus = 2 Payment_FAILED Payment_PaymentStatus = 3 ) // Enum value maps for Payment_PaymentStatus. var ( Payment_PaymentStatus_name = map[int32]string{ 0: "UNKNOWN", 1: "IN_FLIGHT", 2: "SUCCEEDED", 3: "FAILED", } Payment_PaymentStatus_value = map[string]int32{ "UNKNOWN": 0, "IN_FLIGHT": 1, "SUCCEEDED": 2, "FAILED": 3, } ) func (x Payment_PaymentStatus) Enum() *Payment_PaymentStatus { p := new(Payment_PaymentStatus) *p = x return p } func (x Payment_PaymentStatus) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (Payment_PaymentStatus) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[16].Descriptor() } func (Payment_PaymentStatus) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[16] } func (x Payment_PaymentStatus) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use Payment_PaymentStatus.Descriptor instead. func (Payment_PaymentStatus) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{129, 0} } type HTLCAttempt_HTLCStatus int32 const ( HTLCAttempt_IN_FLIGHT HTLCAttempt_HTLCStatus = 0 HTLCAttempt_SUCCEEDED HTLCAttempt_HTLCStatus = 1 HTLCAttempt_FAILED HTLCAttempt_HTLCStatus = 2 ) // Enum value maps for HTLCAttempt_HTLCStatus. var ( HTLCAttempt_HTLCStatus_name = map[int32]string{ 0: "IN_FLIGHT", 1: "SUCCEEDED", 2: "FAILED", } HTLCAttempt_HTLCStatus_value = map[string]int32{ "IN_FLIGHT": 0, "SUCCEEDED": 1, "FAILED": 2, } ) func (x HTLCAttempt_HTLCStatus) Enum() *HTLCAttempt_HTLCStatus { p := new(HTLCAttempt_HTLCStatus) *p = x return p } func (x HTLCAttempt_HTLCStatus) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (HTLCAttempt_HTLCStatus) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[17].Descriptor() } func (HTLCAttempt_HTLCStatus) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[17] } func (x HTLCAttempt_HTLCStatus) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use HTLCAttempt_HTLCStatus.Descriptor instead. func (HTLCAttempt_HTLCStatus) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{130, 0} } type Failure_FailureCode int32 const ( // //The numbers assigned in this enumeration match the failure codes as //defined in BOLT #4. Because protobuf 3 requires enums to start with 0, //a RESERVED value is added. Failure_RESERVED Failure_FailureCode = 0 Failure_INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS Failure_FailureCode = 1 Failure_INCORRECT_PAYMENT_AMOUNT Failure_FailureCode = 2 Failure_FINAL_INCORRECT_CLTV_EXPIRY Failure_FailureCode = 3 Failure_FINAL_INCORRECT_HTLC_AMOUNT Failure_FailureCode = 4 Failure_FINAL_EXPIRY_TOO_SOON Failure_FailureCode = 5 Failure_INVALID_REALM Failure_FailureCode = 6 Failure_EXPIRY_TOO_SOON Failure_FailureCode = 7 Failure_INVALID_ONION_VERSION Failure_FailureCode = 8 Failure_INVALID_ONION_HMAC Failure_FailureCode = 9 Failure_INVALID_ONION_KEY Failure_FailureCode = 10 Failure_AMOUNT_BELOW_MINIMUM Failure_FailureCode = 11 Failure_FEE_INSUFFICIENT Failure_FailureCode = 12 Failure_INCORRECT_CLTV_EXPIRY Failure_FailureCode = 13 Failure_CHANNEL_DISABLED Failure_FailureCode = 14 Failure_TEMPORARY_CHANNEL_FAILURE Failure_FailureCode = 15 Failure_REQUIRED_NODE_FEATURE_MISSING Failure_FailureCode = 16 Failure_REQUIRED_CHANNEL_FEATURE_MISSING Failure_FailureCode = 17 Failure_UNKNOWN_NEXT_PEER Failure_FailureCode = 18 Failure_TEMPORARY_NODE_FAILURE Failure_FailureCode = 19 Failure_PERMANENT_NODE_FAILURE Failure_FailureCode = 20 Failure_PERMANENT_CHANNEL_FAILURE Failure_FailureCode = 21 Failure_EXPIRY_TOO_FAR Failure_FailureCode = 22 Failure_MPP_TIMEOUT Failure_FailureCode = 23 Failure_INVALID_ONION_PAYLOAD Failure_FailureCode = 24 // //An internal error occurred. Failure_INTERNAL_FAILURE Failure_FailureCode = 997 // //The error source is known, but the failure itself couldn't be decoded. Failure_UNKNOWN_FAILURE Failure_FailureCode = 998 // //An unreadable failure result is returned if the received failure message //cannot be decrypted. In that case the error source is unknown. Failure_UNREADABLE_FAILURE Failure_FailureCode = 999 ) // Enum value maps for Failure_FailureCode. var ( Failure_FailureCode_name = map[int32]string{ 0: "RESERVED", 1: "INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS", 2: "INCORRECT_PAYMENT_AMOUNT", 3: "FINAL_INCORRECT_CLTV_EXPIRY", 4: "FINAL_INCORRECT_HTLC_AMOUNT", 5: "FINAL_EXPIRY_TOO_SOON", 6: "INVALID_REALM", 7: "EXPIRY_TOO_SOON", 8: "INVALID_ONION_VERSION", 9: "INVALID_ONION_HMAC", 10: "INVALID_ONION_KEY", 11: "AMOUNT_BELOW_MINIMUM", 12: "FEE_INSUFFICIENT", 13: "INCORRECT_CLTV_EXPIRY", 14: "CHANNEL_DISABLED", 15: "TEMPORARY_CHANNEL_FAILURE", 16: "REQUIRED_NODE_FEATURE_MISSING", 17: "REQUIRED_CHANNEL_FEATURE_MISSING", 18: "UNKNOWN_NEXT_PEER", 19: "TEMPORARY_NODE_FAILURE", 20: "PERMANENT_NODE_FAILURE", 21: "PERMANENT_CHANNEL_FAILURE", 22: "EXPIRY_TOO_FAR", 23: "MPP_TIMEOUT", 24: "INVALID_ONION_PAYLOAD", 997: "INTERNAL_FAILURE", 998: "UNKNOWN_FAILURE", 999: "UNREADABLE_FAILURE", } Failure_FailureCode_value = map[string]int32{ "RESERVED": 0, "INCORRECT_OR_UNKNOWN_PAYMENT_DETAILS": 1, "INCORRECT_PAYMENT_AMOUNT": 2, "FINAL_INCORRECT_CLTV_EXPIRY": 3, "FINAL_INCORRECT_HTLC_AMOUNT": 4, "FINAL_EXPIRY_TOO_SOON": 5, "INVALID_REALM": 6, "EXPIRY_TOO_SOON": 7, "INVALID_ONION_VERSION": 8, "INVALID_ONION_HMAC": 9, "INVALID_ONION_KEY": 10, "AMOUNT_BELOW_MINIMUM": 11, "FEE_INSUFFICIENT": 12, "INCORRECT_CLTV_EXPIRY": 13, "CHANNEL_DISABLED": 14, "TEMPORARY_CHANNEL_FAILURE": 15, "REQUIRED_NODE_FEATURE_MISSING": 16, "REQUIRED_CHANNEL_FEATURE_MISSING": 17, "UNKNOWN_NEXT_PEER": 18, "TEMPORARY_NODE_FAILURE": 19, "PERMANENT_NODE_FAILURE": 20, "PERMANENT_CHANNEL_FAILURE": 21, "EXPIRY_TOO_FAR": 22, "MPP_TIMEOUT": 23, "INVALID_ONION_PAYLOAD": 24, "INTERNAL_FAILURE": 997, "UNKNOWN_FAILURE": 998, "UNREADABLE_FAILURE": 999, } ) func (x Failure_FailureCode) Enum() *Failure_FailureCode { p := new(Failure_FailureCode) *p = x return p } func (x Failure_FailureCode) String() string { return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) } func (Failure_FailureCode) Descriptor() protoreflect.EnumDescriptor { return file_lightning_proto_enumTypes[18].Descriptor() } func (Failure_FailureCode) Type() protoreflect.EnumType { return &file_lightning_proto_enumTypes[18] } func (x Failure_FailureCode) Number() protoreflect.EnumNumber { return protoreflect.EnumNumber(x) } // Deprecated: Use Failure_FailureCode.Descriptor instead. func (Failure_FailureCode) EnumDescriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{173, 0} } type SubscribeCustomMessagesRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *SubscribeCustomMessagesRequest) Reset() { *x = SubscribeCustomMessagesRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SubscribeCustomMessagesRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SubscribeCustomMessagesRequest) ProtoMessage() {} func (x *SubscribeCustomMessagesRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SubscribeCustomMessagesRequest.ProtoReflect.Descriptor instead. func (*SubscribeCustomMessagesRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{0} } type CustomMessage struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Peer from which the message originates Peer []byte `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` // Message type. This value will be in the custom range (>= 32768). Type uint32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` // Raw message data Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` } func (x *CustomMessage) Reset() { *x = CustomMessage{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[1] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *CustomMessage) String() string { return protoimpl.X.MessageStringOf(x) } func (*CustomMessage) ProtoMessage() {} func (x *CustomMessage) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[1] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use CustomMessage.ProtoReflect.Descriptor instead. func (*CustomMessage) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{1} } func (x *CustomMessage) GetPeer() []byte { if x != nil { return x.Peer } return nil } func (x *CustomMessage) GetType() uint32 { if x != nil { return x.Type } return 0 } func (x *CustomMessage) GetData() []byte { if x != nil { return x.Data } return nil } type SendCustomMessageRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Peer to send the message to Peer []byte `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` // Message type. This value needs to be in the custom range (>= 32768). Type uint32 `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"` // Raw message data. Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` } func (x *SendCustomMessageRequest) Reset() { *x = SendCustomMessageRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendCustomMessageRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendCustomMessageRequest) ProtoMessage() {} func (x *SendCustomMessageRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendCustomMessageRequest.ProtoReflect.Descriptor instead. func (*SendCustomMessageRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{2} } func (x *SendCustomMessageRequest) GetPeer() []byte { if x != nil { return x.Peer } return nil } func (x *SendCustomMessageRequest) GetType() uint32 { if x != nil { return x.Type } return 0 } func (x *SendCustomMessageRequest) GetData() []byte { if x != nil { return x.Data } return nil } type SendCustomMessageResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *SendCustomMessageResponse) Reset() { *x = SendCustomMessageResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendCustomMessageResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendCustomMessageResponse) ProtoMessage() {} func (x *SendCustomMessageResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[3] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendCustomMessageResponse.ProtoReflect.Descriptor instead. func (*SendCustomMessageResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{3} } type Utxo struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The type of address AddressType AddressType `protobuf:"varint,1,opt,name=address_type,json=addressType,proto3,enum=lnrpc.AddressType" json:"address_type,omitempty"` // The address Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"` // The value of the unspent coin in satoshis AmountSat int64 `protobuf:"varint,3,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"` // The pkscript in hex PkScript string `protobuf:"bytes,4,opt,name=pk_script,json=pkScript,proto3" json:"pk_script,omitempty"` // The outpoint in format txid:n Outpoint *OutPoint `protobuf:"bytes,5,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // The number of confirmations for the Utxo Confirmations int64 `protobuf:"varint,6,opt,name=confirmations,proto3" json:"confirmations,omitempty"` } func (x *Utxo) Reset() { *x = Utxo{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Utxo) String() string { return protoimpl.X.MessageStringOf(x) } func (*Utxo) ProtoMessage() {} func (x *Utxo) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Utxo.ProtoReflect.Descriptor instead. func (*Utxo) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{4} } func (x *Utxo) GetAddressType() AddressType { if x != nil { return x.AddressType } return AddressType_WITNESS_PUBKEY_HASH } func (x *Utxo) GetAddress() string { if x != nil { return x.Address } return "" } func (x *Utxo) GetAmountSat() int64 { if x != nil { return x.AmountSat } return 0 } func (x *Utxo) GetPkScript() string { if x != nil { return x.PkScript } return "" } func (x *Utxo) GetOutpoint() *OutPoint { if x != nil { return x.Outpoint } return nil } func (x *Utxo) GetConfirmations() int64 { if x != nil { return x.Confirmations } return 0 } type Transaction struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The transaction hash TxHash string `protobuf:"bytes,1,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"` // The transaction amount, denominated in satoshis Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` // The number of confirmations NumConfirmations int32 `protobuf:"varint,3,opt,name=num_confirmations,json=numConfirmations,proto3" json:"num_confirmations,omitempty"` // The hash of the block this transaction was included in BlockHash string `protobuf:"bytes,4,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` // The height of the block this transaction was included in BlockHeight int32 `protobuf:"varint,5,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` // Timestamp of this transaction TimeStamp int64 `protobuf:"varint,6,opt,name=time_stamp,json=timeStamp,proto3" json:"time_stamp,omitempty"` // Fees paid for this transaction TotalFees int64 `protobuf:"varint,7,opt,name=total_fees,json=totalFees,proto3" json:"total_fees,omitempty"` // Addresses that received funds for this transaction DestAddresses []string `protobuf:"bytes,8,rep,name=dest_addresses,json=destAddresses,proto3" json:"dest_addresses,omitempty"` // The raw transaction hex. RawTxHex string `protobuf:"bytes,9,opt,name=raw_tx_hex,json=rawTxHex,proto3" json:"raw_tx_hex,omitempty"` // A label that was optionally set on transaction broadcast. Label string `protobuf:"bytes,10,opt,name=label,proto3" json:"label,omitempty"` } func (x *Transaction) Reset() { *x = Transaction{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Transaction) String() string { return protoimpl.X.MessageStringOf(x) } func (*Transaction) ProtoMessage() {} func (x *Transaction) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[5] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Transaction.ProtoReflect.Descriptor instead. func (*Transaction) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{5} } func (x *Transaction) GetTxHash() string { if x != nil { return x.TxHash } return "" } func (x *Transaction) GetAmount() int64 { if x != nil { return x.Amount } return 0 } func (x *Transaction) GetNumConfirmations() int32 { if x != nil { return x.NumConfirmations } return 0 } func (x *Transaction) GetBlockHash() string { if x != nil { return x.BlockHash } return "" } func (x *Transaction) GetBlockHeight() int32 { if x != nil { return x.BlockHeight } return 0 } func (x *Transaction) GetTimeStamp() int64 { if x != nil { return x.TimeStamp } return 0 } func (x *Transaction) GetTotalFees() int64 { if x != nil { return x.TotalFees } return 0 } func (x *Transaction) GetDestAddresses() []string { if x != nil { return x.DestAddresses } return nil } func (x *Transaction) GetRawTxHex() string { if x != nil { return x.RawTxHex } return "" } func (x *Transaction) GetLabel() string { if x != nil { return x.Label } return "" } type GetTransactionsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The height from which to list transactions, inclusive. If this value is //greater than end_height, transactions will be read in reverse. StartHeight int32 `protobuf:"varint,1,opt,name=start_height,json=startHeight,proto3" json:"start_height,omitempty"` // //The height until which to list transactions, inclusive. To include //unconfirmed transactions, this value should be set to -1, which will //return transactions from start_height until the current chain tip and //unconfirmed transactions. If no end_height is provided, the call will //default to this option. EndHeight int32 `protobuf:"varint,2,opt,name=end_height,json=endHeight,proto3" json:"end_height,omitempty"` // An optional filter to only include transactions relevant to an account. Account string `protobuf:"bytes,3,opt,name=account,proto3" json:"account,omitempty"` } func (x *GetTransactionsRequest) Reset() { *x = GetTransactionsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GetTransactionsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*GetTransactionsRequest) ProtoMessage() {} func (x *GetTransactionsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GetTransactionsRequest.ProtoReflect.Descriptor instead. func (*GetTransactionsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{6} } func (x *GetTransactionsRequest) GetStartHeight() int32 { if x != nil { return x.StartHeight } return 0 } func (x *GetTransactionsRequest) GetEndHeight() int32 { if x != nil { return x.EndHeight } return 0 } func (x *GetTransactionsRequest) GetAccount() string { if x != nil { return x.Account } return "" } type TransactionDetails struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of transactions relevant to the wallet. Transactions []*Transaction `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"` } func (x *TransactionDetails) Reset() { *x = TransactionDetails{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *TransactionDetails) String() string { return protoimpl.X.MessageStringOf(x) } func (*TransactionDetails) ProtoMessage() {} func (x *TransactionDetails) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[7] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use TransactionDetails.ProtoReflect.Descriptor instead. func (*TransactionDetails) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{7} } func (x *TransactionDetails) GetTransactions() []*Transaction { if x != nil { return x.Transactions } return nil } type FeeLimit struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Limit: // *FeeLimit_Fixed // *FeeLimit_FixedMsat // *FeeLimit_Percent Limit isFeeLimit_Limit `protobuf_oneof:"limit"` } func (x *FeeLimit) Reset() { *x = FeeLimit{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FeeLimit) String() string { return protoimpl.X.MessageStringOf(x) } func (*FeeLimit) ProtoMessage() {} func (x *FeeLimit) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FeeLimit.ProtoReflect.Descriptor instead. func (*FeeLimit) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{8} } func (m *FeeLimit) GetLimit() isFeeLimit_Limit { if m != nil { return m.Limit } return nil } func (x *FeeLimit) GetFixed() int64 { if x, ok := x.GetLimit().(*FeeLimit_Fixed); ok { return x.Fixed } return 0 } func (x *FeeLimit) GetFixedMsat() int64 { if x, ok := x.GetLimit().(*FeeLimit_FixedMsat); ok { return x.FixedMsat } return 0 } func (x *FeeLimit) GetPercent() int64 { if x, ok := x.GetLimit().(*FeeLimit_Percent); ok { return x.Percent } return 0 } type isFeeLimit_Limit interface { isFeeLimit_Limit() } type FeeLimit_Fixed struct { // //The fee limit expressed as a fixed amount of satoshis. // //The fields fixed and fixed_msat are mutually exclusive. Fixed int64 `protobuf:"varint,1,opt,name=fixed,proto3,oneof"` } type FeeLimit_FixedMsat struct { // //The fee limit expressed as a fixed amount of millisatoshis. // //The fields fixed and fixed_msat are mutually exclusive. FixedMsat int64 `protobuf:"varint,3,opt,name=fixed_msat,json=fixedMsat,proto3,oneof"` } type FeeLimit_Percent struct { // The fee limit expressed as a percentage of the payment amount. Percent int64 `protobuf:"varint,2,opt,name=percent,proto3,oneof"` } func (*FeeLimit_Fixed) isFeeLimit_Limit() {} func (*FeeLimit_FixedMsat) isFeeLimit_Limit() {} func (*FeeLimit_Percent) isFeeLimit_Limit() {} type SendRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The identity pubkey of the payment recipient. When using REST, this field //must be encoded as base64. Dest []byte `protobuf:"bytes,1,opt,name=dest,proto3" json:"dest,omitempty"` // //The hex-encoded identity pubkey of the payment recipient. Deprecated now //that the REST gateway supports base64 encoding of bytes fields. // // Deprecated: Do not use. DestString string `protobuf:"bytes,2,opt,name=dest_string,json=destString,proto3" json:"dest_string,omitempty"` // //The amount to send expressed in satoshis. // //The fields amt and amt_msat are mutually exclusive. Amt int64 `protobuf:"varint,3,opt,name=amt,proto3" json:"amt,omitempty"` // //The amount to send expressed in millisatoshis. // //The fields amt and amt_msat are mutually exclusive. AmtMsat int64 `protobuf:"varint,12,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"` // //The hash to use within the payment's HTLC. When using REST, this field //must be encoded as base64. PaymentHash []byte `protobuf:"bytes,4,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` // //The hex-encoded hash to use within the payment's HTLC. Deprecated now //that the REST gateway supports base64 encoding of bytes fields. // // Deprecated: Do not use. PaymentHashString string `protobuf:"bytes,5,opt,name=payment_hash_string,json=paymentHashString,proto3" json:"payment_hash_string,omitempty"` // //A bare-bones invoice for a payment within the Lightning Network. With the //details of the invoice, the sender has all the data necessary to send a //payment to the recipient. PaymentRequest string `protobuf:"bytes,6,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` // //The CLTV delta from the current height that should be used to set the //timelock for the final hop. FinalCltvDelta int32 `protobuf:"varint,7,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"` // //The maximum number of satoshis that will be paid as a fee of the payment. //This value can be represented either as a percentage of the amount being //sent, or as a fixed amount of the maximum fee the user is willing the pay to //send the payment. FeeLimit *FeeLimit `protobuf:"bytes,8,opt,name=fee_limit,json=feeLimit,proto3" json:"fee_limit,omitempty"` // //The channel id of the channel that must be taken to the first hop. If zero, //any channel may be used. OutgoingChanId uint64 `protobuf:"varint,9,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"` // //The pubkey of the last hop of the route. If empty, any hop may be used. LastHopPubkey []byte `protobuf:"bytes,13,opt,name=last_hop_pubkey,json=lastHopPubkey,proto3" json:"last_hop_pubkey,omitempty"` // //An optional maximum total time lock for the route. This should not exceed //lnd's `--max-cltv-expiry` setting. If zero, then the value of //`--max-cltv-expiry` is enforced. CltvLimit uint32 `protobuf:"varint,10,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,omitempty"` // //An optional field that can be used to pass an arbitrary set of TLV records //to a peer which understands the new records. This can be used to pass //application specific data during the payment attempt. Record types are //required to be in the custom range >= 65536. When using REST, the values //must be encoded as base64. DestCustomRecords map[uint64][]byte `protobuf:"bytes,11,rep,name=dest_custom_records,json=destCustomRecords,proto3" json:"dest_custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // If set, circular payments to self are permitted. AllowSelfPayment bool `protobuf:"varint,14,opt,name=allow_self_payment,json=allowSelfPayment,proto3" json:"allow_self_payment,omitempty"` // //Features assumed to be supported by the final node. All transitive feature //dependencies must also be set properly. For a given feature bit pair, either //optional or remote may be set, but not both. If this field is nil or empty, //the router will try to load destination features from the graph as a //fallback. DestFeatures []FeatureBit `protobuf:"varint,15,rep,packed,name=dest_features,json=destFeatures,proto3,enum=lnrpc.FeatureBit" json:"dest_features,omitempty"` // //The payment address of the generated invoice. PaymentAddr []byte `protobuf:"bytes,16,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` } func (x *SendRequest) Reset() { *x = SendRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendRequest) ProtoMessage() {} func (x *SendRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendRequest.ProtoReflect.Descriptor instead. func (*SendRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{9} } func (x *SendRequest) GetDest() []byte { if x != nil { return x.Dest } return nil } // Deprecated: Do not use. func (x *SendRequest) GetDestString() string { if x != nil { return x.DestString } return "" } func (x *SendRequest) GetAmt() int64 { if x != nil { return x.Amt } return 0 } func (x *SendRequest) GetAmtMsat() int64 { if x != nil { return x.AmtMsat } return 0 } func (x *SendRequest) GetPaymentHash() []byte { if x != nil { return x.PaymentHash } return nil } // Deprecated: Do not use. func (x *SendRequest) GetPaymentHashString() string { if x != nil { return x.PaymentHashString } return "" } func (x *SendRequest) GetPaymentRequest() string { if x != nil { return x.PaymentRequest } return "" } func (x *SendRequest) GetFinalCltvDelta() int32 { if x != nil { return x.FinalCltvDelta } return 0 } func (x *SendRequest) GetFeeLimit() *FeeLimit { if x != nil { return x.FeeLimit } return nil } func (x *SendRequest) GetOutgoingChanId() uint64 { if x != nil { return x.OutgoingChanId } return 0 } func (x *SendRequest) GetLastHopPubkey() []byte { if x != nil { return x.LastHopPubkey } return nil } func (x *SendRequest) GetCltvLimit() uint32 { if x != nil { return x.CltvLimit } return 0 } func (x *SendRequest) GetDestCustomRecords() map[uint64][]byte { if x != nil { return x.DestCustomRecords } return nil } func (x *SendRequest) GetAllowSelfPayment() bool { if x != nil { return x.AllowSelfPayment } return false } func (x *SendRequest) GetDestFeatures() []FeatureBit { if x != nil { return x.DestFeatures } return nil } func (x *SendRequest) GetPaymentAddr() []byte { if x != nil { return x.PaymentAddr } return nil } type SendResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields PaymentError string `protobuf:"bytes,1,opt,name=payment_error,json=paymentError,proto3" json:"payment_error,omitempty"` PaymentPreimage []byte `protobuf:"bytes,2,opt,name=payment_preimage,json=paymentPreimage,proto3" json:"payment_preimage,omitempty"` PaymentRoute *Route `protobuf:"bytes,3,opt,name=payment_route,json=paymentRoute,proto3" json:"payment_route,omitempty"` PaymentHash []byte `protobuf:"bytes,4,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` } func (x *SendResponse) Reset() { *x = SendResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendResponse) ProtoMessage() {} func (x *SendResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendResponse.ProtoReflect.Descriptor instead. func (*SendResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{10} } func (x *SendResponse) GetPaymentError() string { if x != nil { return x.PaymentError } return "" } func (x *SendResponse) GetPaymentPreimage() []byte { if x != nil { return x.PaymentPreimage } return nil } func (x *SendResponse) GetPaymentRoute() *Route { if x != nil { return x.PaymentRoute } return nil } func (x *SendResponse) GetPaymentHash() []byte { if x != nil { return x.PaymentHash } return nil } type SendToRouteRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The payment hash to use for the HTLC. When using REST, this field must be //encoded as base64. PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` // //An optional hex-encoded payment hash to be used for the HTLC. Deprecated now //that the REST gateway supports base64 encoding of bytes fields. // // Deprecated: Do not use. PaymentHashString string `protobuf:"bytes,2,opt,name=payment_hash_string,json=paymentHashString,proto3" json:"payment_hash_string,omitempty"` // Route that should be used to attempt to complete the payment. Route *Route `protobuf:"bytes,4,opt,name=route,proto3" json:"route,omitempty"` } func (x *SendToRouteRequest) Reset() { *x = SendToRouteRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendToRouteRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendToRouteRequest) ProtoMessage() {} func (x *SendToRouteRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendToRouteRequest.ProtoReflect.Descriptor instead. func (*SendToRouteRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{11} } func (x *SendToRouteRequest) GetPaymentHash() []byte { if x != nil { return x.PaymentHash } return nil } // Deprecated: Do not use. func (x *SendToRouteRequest) GetPaymentHashString() string { if x != nil { return x.PaymentHashString } return "" } func (x *SendToRouteRequest) GetRoute() *Route { if x != nil { return x.Route } return nil } type ChannelAcceptRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pubkey of the node that wishes to open an inbound channel. NodePubkey []byte `protobuf:"bytes,1,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"` // The hash of the genesis block that the proposed channel resides in. ChainHash []byte `protobuf:"bytes,2,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` // The pending channel id. PendingChanId []byte `protobuf:"bytes,3,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // The funding amount in satoshis that initiator wishes to use in the // channel. FundingAmt uint64 `protobuf:"varint,4,opt,name=funding_amt,json=fundingAmt,proto3" json:"funding_amt,omitempty"` // The push amount of the proposed channel in millisatoshis. PushAmt uint64 `protobuf:"varint,5,opt,name=push_amt,json=pushAmt,proto3" json:"push_amt,omitempty"` // The dust limit of the initiator's commitment tx. DustLimit uint64 `protobuf:"varint,6,opt,name=dust_limit,json=dustLimit,proto3" json:"dust_limit,omitempty"` // The maximum amount of coins in millisatoshis that can be pending in this // channel. MaxValueInFlight uint64 `protobuf:"varint,7,opt,name=max_value_in_flight,json=maxValueInFlight,proto3" json:"max_value_in_flight,omitempty"` // The minimum amount of satoshis the initiator requires us to have at all // times. ChannelReserve uint64 `protobuf:"varint,8,opt,name=channel_reserve,json=channelReserve,proto3" json:"channel_reserve,omitempty"` // The smallest HTLC in millisatoshis that the initiator will accept. MinHtlc uint64 `protobuf:"varint,9,opt,name=min_htlc,json=minHtlc,proto3" json:"min_htlc,omitempty"` // The initial fee rate that the initiator suggests for both commitment // transactions. FeePerKw uint64 `protobuf:"varint,10,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` // //The number of blocks to use for the relative time lock in the pay-to-self //output of both commitment transactions. CsvDelay uint32 `protobuf:"varint,11,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` // The total number of incoming HTLC's that the initiator will accept. MaxAcceptedHtlcs uint32 `protobuf:"varint,12,opt,name=max_accepted_htlcs,json=maxAcceptedHtlcs,proto3" json:"max_accepted_htlcs,omitempty"` // A bit-field which the initiator uses to specify proposed channel // behavior. ChannelFlags uint32 `protobuf:"varint,13,opt,name=channel_flags,json=channelFlags,proto3" json:"channel_flags,omitempty"` // The commitment type the initiator wishes to use for the proposed channel. CommitmentType CommitmentType `protobuf:"varint,14,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` } func (x *ChannelAcceptRequest) Reset() { *x = ChannelAcceptRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelAcceptRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelAcceptRequest) ProtoMessage() {} func (x *ChannelAcceptRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelAcceptRequest.ProtoReflect.Descriptor instead. func (*ChannelAcceptRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{12} } func (x *ChannelAcceptRequest) GetNodePubkey() []byte { if x != nil { return x.NodePubkey } return nil } func (x *ChannelAcceptRequest) GetChainHash() []byte { if x != nil { return x.ChainHash } return nil } func (x *ChannelAcceptRequest) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *ChannelAcceptRequest) GetFundingAmt() uint64 { if x != nil { return x.FundingAmt } return 0 } func (x *ChannelAcceptRequest) GetPushAmt() uint64 { if x != nil { return x.PushAmt } return 0 } func (x *ChannelAcceptRequest) GetDustLimit() uint64 { if x != nil { return x.DustLimit } return 0 } func (x *ChannelAcceptRequest) GetMaxValueInFlight() uint64 { if x != nil { return x.MaxValueInFlight } return 0 } func (x *ChannelAcceptRequest) GetChannelReserve() uint64 { if x != nil { return x.ChannelReserve } return 0 } func (x *ChannelAcceptRequest) GetMinHtlc() uint64 { if x != nil { return x.MinHtlc } return 0 } func (x *ChannelAcceptRequest) GetFeePerKw() uint64 { if x != nil { return x.FeePerKw } return 0 } func (x *ChannelAcceptRequest) GetCsvDelay() uint32 { if x != nil { return x.CsvDelay } return 0 } func (x *ChannelAcceptRequest) GetMaxAcceptedHtlcs() uint32 { if x != nil { return x.MaxAcceptedHtlcs } return 0 } func (x *ChannelAcceptRequest) GetChannelFlags() uint32 { if x != nil { return x.ChannelFlags } return 0 } func (x *ChannelAcceptRequest) GetCommitmentType() CommitmentType { if x != nil { return x.CommitmentType } return CommitmentType_UNKNOWN_COMMITMENT_TYPE } type ChannelAcceptResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Whether or not the client accepts the channel. Accept bool `protobuf:"varint,1,opt,name=accept,proto3" json:"accept,omitempty"` // The pending channel id to which this response applies. PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //An optional error to send the initiating party to indicate why the channel //was rejected. This field *should not* contain sensitive information, it will //be sent to the initiating party. This field should only be set if accept is //false, the channel will be rejected if an error is set with accept=true //because the meaning of this response is ambiguous. Limited to 500 //characters. Error string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"` // //The upfront shutdown address to use if the initiating peer supports option //upfront shutdown script (see ListPeers for the features supported). Note //that the channel open will fail if this value is set for a peer that does //not support this feature bit. UpfrontShutdown string `protobuf:"bytes,4,opt,name=upfront_shutdown,json=upfrontShutdown,proto3" json:"upfront_shutdown,omitempty"` // //The csv delay (in blocks) that we require for the remote party. CsvDelay uint32 `protobuf:"varint,5,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` // //The reserve amount in satoshis that we require the remote peer to adhere to. //We require that the remote peer always have some reserve amount allocated to //them so that there is always a disincentive to broadcast old state (if they //hold 0 sats on their side of the channel, there is nothing to lose). ReserveSat uint64 `protobuf:"varint,6,opt,name=reserve_sat,json=reserveSat,proto3" json:"reserve_sat,omitempty"` // //The maximum amount of funds in millisatoshis that we allow the remote peer //to have in outstanding htlcs. InFlightMaxMsat uint64 `protobuf:"varint,7,opt,name=in_flight_max_msat,json=inFlightMaxMsat,proto3" json:"in_flight_max_msat,omitempty"` // //The maximum number of htlcs that the remote peer can offer us. MaxHtlcCount uint32 `protobuf:"varint,8,opt,name=max_htlc_count,json=maxHtlcCount,proto3" json:"max_htlc_count,omitempty"` // //The minimum value in millisatoshis for incoming htlcs on the channel. MinHtlcIn uint64 `protobuf:"varint,9,opt,name=min_htlc_in,json=minHtlcIn,proto3" json:"min_htlc_in,omitempty"` // //The number of confirmations we require before we consider the channel open. MinAcceptDepth uint32 `protobuf:"varint,10,opt,name=min_accept_depth,json=minAcceptDepth,proto3" json:"min_accept_depth,omitempty"` } func (x *ChannelAcceptResponse) Reset() { *x = ChannelAcceptResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelAcceptResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelAcceptResponse) ProtoMessage() {} func (x *ChannelAcceptResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelAcceptResponse.ProtoReflect.Descriptor instead. func (*ChannelAcceptResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{13} } func (x *ChannelAcceptResponse) GetAccept() bool { if x != nil { return x.Accept } return false } func (x *ChannelAcceptResponse) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *ChannelAcceptResponse) GetError() string { if x != nil { return x.Error } return "" } func (x *ChannelAcceptResponse) GetUpfrontShutdown() string { if x != nil { return x.UpfrontShutdown } return "" } func (x *ChannelAcceptResponse) GetCsvDelay() uint32 { if x != nil { return x.CsvDelay } return 0 } func (x *ChannelAcceptResponse) GetReserveSat() uint64 { if x != nil { return x.ReserveSat } return 0 } func (x *ChannelAcceptResponse) GetInFlightMaxMsat() uint64 { if x != nil { return x.InFlightMaxMsat } return 0 } func (x *ChannelAcceptResponse) GetMaxHtlcCount() uint32 { if x != nil { return x.MaxHtlcCount } return 0 } func (x *ChannelAcceptResponse) GetMinHtlcIn() uint64 { if x != nil { return x.MinHtlcIn } return 0 } func (x *ChannelAcceptResponse) GetMinAcceptDepth() uint32 { if x != nil { return x.MinAcceptDepth } return 0 } type ChannelPoint struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to FundingTxid: // *ChannelPoint_FundingTxidBytes // *ChannelPoint_FundingTxidStr FundingTxid isChannelPoint_FundingTxid `protobuf_oneof:"funding_txid"` // The index of the output of the funding transaction OutputIndex uint32 `protobuf:"varint,3,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` } func (x *ChannelPoint) Reset() { *x = ChannelPoint{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelPoint) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelPoint) ProtoMessage() {} func (x *ChannelPoint) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelPoint.ProtoReflect.Descriptor instead. func (*ChannelPoint) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{14} } func (m *ChannelPoint) GetFundingTxid() isChannelPoint_FundingTxid { if m != nil { return m.FundingTxid } return nil } func (x *ChannelPoint) GetFundingTxidBytes() []byte { if x, ok := x.GetFundingTxid().(*ChannelPoint_FundingTxidBytes); ok { return x.FundingTxidBytes } return nil } func (x *ChannelPoint) GetFundingTxidStr() string { if x, ok := x.GetFundingTxid().(*ChannelPoint_FundingTxidStr); ok { return x.FundingTxidStr } return "" } func (x *ChannelPoint) GetOutputIndex() uint32 { if x != nil { return x.OutputIndex } return 0 } type isChannelPoint_FundingTxid interface { isChannelPoint_FundingTxid() } type ChannelPoint_FundingTxidBytes struct { // //Txid of the funding transaction. When using REST, this field must be //encoded as base64. FundingTxidBytes []byte `protobuf:"bytes,1,opt,name=funding_txid_bytes,json=fundingTxidBytes,proto3,oneof"` } type ChannelPoint_FundingTxidStr struct { // //Hex-encoded string representing the byte-reversed hash of the funding //transaction. FundingTxidStr string `protobuf:"bytes,2,opt,name=funding_txid_str,json=fundingTxidStr,proto3,oneof"` } func (*ChannelPoint_FundingTxidBytes) isChannelPoint_FundingTxid() {} func (*ChannelPoint_FundingTxidStr) isChannelPoint_FundingTxid() {} type OutPoint struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Raw bytes representing the transaction id. TxidBytes []byte `protobuf:"bytes,1,opt,name=txid_bytes,json=txidBytes,proto3" json:"txid_bytes,omitempty"` // Reversed, hex-encoded string representing the transaction id. TxidStr string `protobuf:"bytes,2,opt,name=txid_str,json=txidStr,proto3" json:"txid_str,omitempty"` // The index of the output on the transaction. OutputIndex uint32 `protobuf:"varint,3,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` } func (x *OutPoint) Reset() { *x = OutPoint{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *OutPoint) String() string { return protoimpl.X.MessageStringOf(x) } func (*OutPoint) ProtoMessage() {} func (x *OutPoint) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use OutPoint.ProtoReflect.Descriptor instead. func (*OutPoint) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{15} } func (x *OutPoint) GetTxidBytes() []byte { if x != nil { return x.TxidBytes } return nil } func (x *OutPoint) GetTxidStr() string { if x != nil { return x.TxidStr } return "" } func (x *OutPoint) GetOutputIndex() uint32 { if x != nil { return x.OutputIndex } return 0 } type LightningAddress struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The identity pubkey of the Lightning node Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"` // The network location of the lightning node, e.g. `69.69.69.69:1337` or // `localhost:10011` Host string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"` } func (x *LightningAddress) Reset() { *x = LightningAddress{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *LightningAddress) String() string { return protoimpl.X.MessageStringOf(x) } func (*LightningAddress) ProtoMessage() {} func (x *LightningAddress) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use LightningAddress.ProtoReflect.Descriptor instead. func (*LightningAddress) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{16} } func (x *LightningAddress) GetPubkey() string { if x != nil { return x.Pubkey } return "" } func (x *LightningAddress) GetHost() string { if x != nil { return x.Host } return "" } type EstimateFeeRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The map from addresses to amounts for the transaction. AddrToAmount map[string]int64 `protobuf:"bytes,1,rep,name=AddrToAmount,proto3" json:"AddrToAmount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` // The target number of blocks that this transaction should be confirmed // by. TargetConf int32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // The minimum number of confirmations each one of your outputs used for // the transaction must satisfy. MinConfs int32 `protobuf:"varint,3,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // Whether unconfirmed outputs should be used as inputs for the transaction. SpendUnconfirmed bool `protobuf:"varint,4,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` } func (x *EstimateFeeRequest) Reset() { *x = EstimateFeeRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *EstimateFeeRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*EstimateFeeRequest) ProtoMessage() {} func (x *EstimateFeeRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use EstimateFeeRequest.ProtoReflect.Descriptor instead. func (*EstimateFeeRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{17} } func (x *EstimateFeeRequest) GetAddrToAmount() map[string]int64 { if x != nil { return x.AddrToAmount } return nil } func (x *EstimateFeeRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } func (x *EstimateFeeRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *EstimateFeeRequest) GetSpendUnconfirmed() bool { if x != nil { return x.SpendUnconfirmed } return false } type EstimateFeeResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The total fee in satoshis. FeeSat int64 `protobuf:"varint,1,opt,name=fee_sat,json=feeSat,proto3" json:"fee_sat,omitempty"` // Deprecated, use sat_per_vbyte. // The fee rate in satoshi/vbyte. // // Deprecated: Do not use. FeerateSatPerByte int64 `protobuf:"varint,2,opt,name=feerate_sat_per_byte,json=feerateSatPerByte,proto3" json:"feerate_sat_per_byte,omitempty"` // The fee rate in satoshi/vbyte. SatPerVbyte uint64 `protobuf:"varint,3,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` } func (x *EstimateFeeResponse) Reset() { *x = EstimateFeeResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *EstimateFeeResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*EstimateFeeResponse) ProtoMessage() {} func (x *EstimateFeeResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use EstimateFeeResponse.ProtoReflect.Descriptor instead. func (*EstimateFeeResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{18} } func (x *EstimateFeeResponse) GetFeeSat() int64 { if x != nil { return x.FeeSat } return 0 } // Deprecated: Do not use. func (x *EstimateFeeResponse) GetFeerateSatPerByte() int64 { if x != nil { return x.FeerateSatPerByte } return 0 } func (x *EstimateFeeResponse) GetSatPerVbyte() uint64 { if x != nil { return x.SatPerVbyte } return 0 } type SendManyRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The map from addresses to amounts AddrToAmount map[string]int64 `protobuf:"bytes,1,rep,name=AddrToAmount,proto3" json:"AddrToAmount,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` // The target number of blocks that this transaction should be confirmed // by. TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // A manual fee rate set in sat/vbyte that should be used when crafting the // transaction. SatPerVbyte uint64 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` // Deprecated, use sat_per_vbyte. // A manual fee rate set in sat/vbyte that should be used when crafting the // transaction. // // Deprecated: Do not use. SatPerByte int64 `protobuf:"varint,5,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // An optional label for the transaction, limited to 500 characters. Label string `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"` // The minimum number of confirmations each one of your outputs used for // the transaction must satisfy. MinConfs int32 `protobuf:"varint,7,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // Whether unconfirmed outputs should be used as inputs for the transaction. SpendUnconfirmed bool `protobuf:"varint,8,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` } func (x *SendManyRequest) Reset() { *x = SendManyRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendManyRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendManyRequest) ProtoMessage() {} func (x *SendManyRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendManyRequest.ProtoReflect.Descriptor instead. func (*SendManyRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{19} } func (x *SendManyRequest) GetAddrToAmount() map[string]int64 { if x != nil { return x.AddrToAmount } return nil } func (x *SendManyRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } func (x *SendManyRequest) GetSatPerVbyte() uint64 { if x != nil { return x.SatPerVbyte } return 0 } // Deprecated: Do not use. func (x *SendManyRequest) GetSatPerByte() int64 { if x != nil { return x.SatPerByte } return 0 } func (x *SendManyRequest) GetLabel() string { if x != nil { return x.Label } return "" } func (x *SendManyRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *SendManyRequest) GetSpendUnconfirmed() bool { if x != nil { return x.SpendUnconfirmed } return false } type SendManyResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The id of the transaction Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` } func (x *SendManyResponse) Reset() { *x = SendManyResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendManyResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendManyResponse) ProtoMessage() {} func (x *SendManyResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendManyResponse.ProtoReflect.Descriptor instead. func (*SendManyResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{20} } func (x *SendManyResponse) GetTxid() string { if x != nil { return x.Txid } return "" } type SendCoinsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The address to send coins to Addr string `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"` // The amount in satoshis to send Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` // The target number of blocks that this transaction should be confirmed // by. TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // A manual fee rate set in sat/vbyte that should be used when crafting the // transaction. SatPerVbyte uint64 `protobuf:"varint,4,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` // Deprecated, use sat_per_vbyte. // A manual fee rate set in sat/vbyte that should be used when crafting the // transaction. // // Deprecated: Do not use. SatPerByte int64 `protobuf:"varint,5,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // //If set, then the amount field will be ignored, and lnd will attempt to //send all the coins under control of the internal wallet to the specified //address. SendAll bool `protobuf:"varint,6,opt,name=send_all,json=sendAll,proto3" json:"send_all,omitempty"` // An optional label for the transaction, limited to 500 characters. Label string `protobuf:"bytes,7,opt,name=label,proto3" json:"label,omitempty"` // The minimum number of confirmations each one of your outputs used for // the transaction must satisfy. MinConfs int32 `protobuf:"varint,8,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // Whether unconfirmed outputs should be used as inputs for the transaction. SpendUnconfirmed bool `protobuf:"varint,9,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` } func (x *SendCoinsRequest) Reset() { *x = SendCoinsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendCoinsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendCoinsRequest) ProtoMessage() {} func (x *SendCoinsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendCoinsRequest.ProtoReflect.Descriptor instead. func (*SendCoinsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{21} } func (x *SendCoinsRequest) GetAddr() string { if x != nil { return x.Addr } return "" } func (x *SendCoinsRequest) GetAmount() int64 { if x != nil { return x.Amount } return 0 } func (x *SendCoinsRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } func (x *SendCoinsRequest) GetSatPerVbyte() uint64 { if x != nil { return x.SatPerVbyte } return 0 } // Deprecated: Do not use. func (x *SendCoinsRequest) GetSatPerByte() int64 { if x != nil { return x.SatPerByte } return 0 } func (x *SendCoinsRequest) GetSendAll() bool { if x != nil { return x.SendAll } return false } func (x *SendCoinsRequest) GetLabel() string { if x != nil { return x.Label } return "" } func (x *SendCoinsRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *SendCoinsRequest) GetSpendUnconfirmed() bool { if x != nil { return x.SpendUnconfirmed } return false } type SendCoinsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The transaction ID of the transaction Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` } func (x *SendCoinsResponse) Reset() { *x = SendCoinsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SendCoinsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*SendCoinsResponse) ProtoMessage() {} func (x *SendCoinsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SendCoinsResponse.ProtoReflect.Descriptor instead. func (*SendCoinsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{22} } func (x *SendCoinsResponse) GetTxid() string { if x != nil { return x.Txid } return "" } type ListUnspentRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The minimum number of confirmations to be included. MinConfs int32 `protobuf:"varint,1,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // The maximum number of confirmations to be included. MaxConfs int32 `protobuf:"varint,2,opt,name=max_confs,json=maxConfs,proto3" json:"max_confs,omitempty"` // An optional filter to only include outputs belonging to an account. Account string `protobuf:"bytes,3,opt,name=account,proto3" json:"account,omitempty"` } func (x *ListUnspentRequest) Reset() { *x = ListUnspentRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListUnspentRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListUnspentRequest) ProtoMessage() {} func (x *ListUnspentRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListUnspentRequest.ProtoReflect.Descriptor instead. func (*ListUnspentRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{23} } func (x *ListUnspentRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *ListUnspentRequest) GetMaxConfs() int32 { if x != nil { return x.MaxConfs } return 0 } func (x *ListUnspentRequest) GetAccount() string { if x != nil { return x.Account } return "" } type ListUnspentResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // A list of utxos Utxos []*Utxo `protobuf:"bytes,1,rep,name=utxos,proto3" json:"utxos,omitempty"` } func (x *ListUnspentResponse) Reset() { *x = ListUnspentResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListUnspentResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListUnspentResponse) ProtoMessage() {} func (x *ListUnspentResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListUnspentResponse.ProtoReflect.Descriptor instead. func (*ListUnspentResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{24} } func (x *ListUnspentResponse) GetUtxos() []*Utxo { if x != nil { return x.Utxos } return nil } type NewAddressRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The type of address to generate. Type AddressType `protobuf:"varint,1,opt,name=type,proto3,enum=lnrpc.AddressType" json:"type,omitempty"` // //The name of the account to generate a new address for. If empty, the //default wallet account is used. Account string `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"` } func (x *NewAddressRequest) Reset() { *x = NewAddressRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NewAddressRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*NewAddressRequest) ProtoMessage() {} func (x *NewAddressRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NewAddressRequest.ProtoReflect.Descriptor instead. func (*NewAddressRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{25} } func (x *NewAddressRequest) GetType() AddressType { if x != nil { return x.Type } return AddressType_WITNESS_PUBKEY_HASH } func (x *NewAddressRequest) GetAccount() string { if x != nil { return x.Account } return "" } type NewAddressResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The newly generated wallet address Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` } func (x *NewAddressResponse) Reset() { *x = NewAddressResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NewAddressResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*NewAddressResponse) ProtoMessage() {} func (x *NewAddressResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NewAddressResponse.ProtoReflect.Descriptor instead. func (*NewAddressResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{26} } func (x *NewAddressResponse) GetAddress() string { if x != nil { return x.Address } return "" } type SignMessageRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The message to be signed. When using REST, this field must be encoded as //base64. Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` // //Instead of the default double-SHA256 hashing of the message before signing, //only use one round of hashing instead. SingleHash bool `protobuf:"varint,2,opt,name=single_hash,json=singleHash,proto3" json:"single_hash,omitempty"` } func (x *SignMessageRequest) Reset() { *x = SignMessageRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SignMessageRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*SignMessageRequest) ProtoMessage() {} func (x *SignMessageRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SignMessageRequest.ProtoReflect.Descriptor instead. func (*SignMessageRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{27} } func (x *SignMessageRequest) GetMsg() []byte { if x != nil { return x.Msg } return nil } func (x *SignMessageRequest) GetSingleHash() bool { if x != nil { return x.SingleHash } return false } type SignMessageResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The signature for the given message Signature string `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` } func (x *SignMessageResponse) Reset() { *x = SignMessageResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SignMessageResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*SignMessageResponse) ProtoMessage() {} func (x *SignMessageResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SignMessageResponse.ProtoReflect.Descriptor instead. func (*SignMessageResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{28} } func (x *SignMessageResponse) GetSignature() string { if x != nil { return x.Signature } return "" } type VerifyMessageRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The message over which the signature is to be verified. When using REST, //this field must be encoded as base64. Msg []byte `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` // The signature to be verified over the given message Signature string `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"` } func (x *VerifyMessageRequest) Reset() { *x = VerifyMessageRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *VerifyMessageRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*VerifyMessageRequest) ProtoMessage() {} func (x *VerifyMessageRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use VerifyMessageRequest.ProtoReflect.Descriptor instead. func (*VerifyMessageRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{29} } func (x *VerifyMessageRequest) GetMsg() []byte { if x != nil { return x.Msg } return nil } func (x *VerifyMessageRequest) GetSignature() string { if x != nil { return x.Signature } return "" } type VerifyMessageResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Whether the signature was valid over the given message Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"` // The pubkey recovered from the signature Pubkey string `protobuf:"bytes,2,opt,name=pubkey,proto3" json:"pubkey,omitempty"` } func (x *VerifyMessageResponse) Reset() { *x = VerifyMessageResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *VerifyMessageResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*VerifyMessageResponse) ProtoMessage() {} func (x *VerifyMessageResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use VerifyMessageResponse.ProtoReflect.Descriptor instead. func (*VerifyMessageResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{30} } func (x *VerifyMessageResponse) GetValid() bool { if x != nil { return x.Valid } return false } func (x *VerifyMessageResponse) GetPubkey() string { if x != nil { return x.Pubkey } return "" } type ConnectPeerRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Lightning address of the peer, in the format `<pubkey>@host` Addr *LightningAddress `protobuf:"bytes,1,opt,name=addr,proto3" json:"addr,omitempty"` // If set, the daemon will attempt to persistently connect to the target // peer. Otherwise, the call will be synchronous. Perm bool `protobuf:"varint,2,opt,name=perm,proto3" json:"perm,omitempty"` // //The connection timeout value (in seconds) for this request. It won't affect //other requests. Timeout uint64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"` } func (x *ConnectPeerRequest) Reset() { *x = ConnectPeerRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ConnectPeerRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ConnectPeerRequest) ProtoMessage() {} func (x *ConnectPeerRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ConnectPeerRequest.ProtoReflect.Descriptor instead. func (*ConnectPeerRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{31} } func (x *ConnectPeerRequest) GetAddr() *LightningAddress { if x != nil { return x.Addr } return nil } func (x *ConnectPeerRequest) GetPerm() bool { if x != nil { return x.Perm } return false } func (x *ConnectPeerRequest) GetTimeout() uint64 { if x != nil { return x.Timeout } return 0 } type ConnectPeerResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ConnectPeerResponse) Reset() { *x = ConnectPeerResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ConnectPeerResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ConnectPeerResponse) ProtoMessage() {} func (x *ConnectPeerResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ConnectPeerResponse.ProtoReflect.Descriptor instead. func (*ConnectPeerResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{32} } type DisconnectPeerRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pubkey of the node to disconnect from PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` } func (x *DisconnectPeerRequest) Reset() { *x = DisconnectPeerRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DisconnectPeerRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*DisconnectPeerRequest) ProtoMessage() {} func (x *DisconnectPeerRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DisconnectPeerRequest.ProtoReflect.Descriptor instead. func (*DisconnectPeerRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{33} } func (x *DisconnectPeerRequest) GetPubKey() string { if x != nil { return x.PubKey } return "" } type DisconnectPeerResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *DisconnectPeerResponse) Reset() { *x = DisconnectPeerResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DisconnectPeerResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*DisconnectPeerResponse) ProtoMessage() {} func (x *DisconnectPeerResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DisconnectPeerResponse.ProtoReflect.Descriptor instead. func (*DisconnectPeerResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{34} } type HTLC struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Incoming bool `protobuf:"varint,1,opt,name=incoming,proto3" json:"incoming,omitempty"` Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` HashLock []byte `protobuf:"bytes,3,opt,name=hash_lock,json=hashLock,proto3" json:"hash_lock,omitempty"` ExpirationHeight uint32 `protobuf:"varint,4,opt,name=expiration_height,json=expirationHeight,proto3" json:"expiration_height,omitempty"` // Index identifying the htlc on the channel. HtlcIndex uint64 `protobuf:"varint,5,opt,name=htlc_index,json=htlcIndex,proto3" json:"htlc_index,omitempty"` // If this HTLC is involved in a forwarding operation, this field indicates // the forwarding channel. For an outgoing htlc, it is the incoming channel. // For an incoming htlc, it is the outgoing channel. When the htlc // originates from this node or this node is the final destination, // forwarding_channel will be zero. The forwarding channel will also be zero // for htlcs that need to be forwarded but don't have a forwarding decision // persisted yet. ForwardingChannel uint64 `protobuf:"varint,6,opt,name=forwarding_channel,json=forwardingChannel,proto3" json:"forwarding_channel,omitempty"` // Index identifying the htlc on the forwarding channel. ForwardingHtlcIndex uint64 `protobuf:"varint,7,opt,name=forwarding_htlc_index,json=forwardingHtlcIndex,proto3" json:"forwarding_htlc_index,omitempty"` } func (x *HTLC) Reset() { *x = HTLC{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *HTLC) String() string { return protoimpl.X.MessageStringOf(x) } func (*HTLC) ProtoMessage() {} func (x *HTLC) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use HTLC.ProtoReflect.Descriptor instead. func (*HTLC) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{35} } func (x *HTLC) GetIncoming() bool { if x != nil { return x.Incoming } return false } func (x *HTLC) GetAmount() int64 { if x != nil { return x.Amount } return 0 } func (x *HTLC) GetHashLock() []byte { if x != nil { return x.HashLock } return nil } func (x *HTLC) GetExpirationHeight() uint32 { if x != nil { return x.ExpirationHeight } return 0 } func (x *HTLC) GetHtlcIndex() uint64 { if x != nil { return x.HtlcIndex } return 0 } func (x *HTLC) GetForwardingChannel() uint64 { if x != nil { return x.ForwardingChannel } return 0 } func (x *HTLC) GetForwardingHtlcIndex() uint64 { if x != nil { return x.ForwardingHtlcIndex } return 0 } type ChannelConstraints struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The CSV delay expressed in relative blocks. If the channel is force closed, //we will need to wait for this many blocks before we can regain our funds. CsvDelay uint32 `protobuf:"varint,1,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` // The minimum satoshis this node is required to reserve in its balance. ChanReserveSat uint64 `protobuf:"varint,2,opt,name=chan_reserve_sat,json=chanReserveSat,proto3" json:"chan_reserve_sat,omitempty"` // The dust limit (in satoshis) of the initiator's commitment tx. DustLimitSat uint64 `protobuf:"varint,3,opt,name=dust_limit_sat,json=dustLimitSat,proto3" json:"dust_limit_sat,omitempty"` // The maximum amount of coins in millisatoshis that can be pending in this // channel. MaxPendingAmtMsat uint64 `protobuf:"varint,4,opt,name=max_pending_amt_msat,json=maxPendingAmtMsat,proto3" json:"max_pending_amt_msat,omitempty"` // The smallest HTLC in millisatoshis that the initiator will accept. MinHtlcMsat uint64 `protobuf:"varint,5,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` // The total number of incoming HTLC's that the initiator will accept. MaxAcceptedHtlcs uint32 `protobuf:"varint,6,opt,name=max_accepted_htlcs,json=maxAcceptedHtlcs,proto3" json:"max_accepted_htlcs,omitempty"` } func (x *ChannelConstraints) Reset() { *x = ChannelConstraints{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelConstraints) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelConstraints) ProtoMessage() {} func (x *ChannelConstraints) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelConstraints.ProtoReflect.Descriptor instead. func (*ChannelConstraints) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{36} } func (x *ChannelConstraints) GetCsvDelay() uint32 { if x != nil { return x.CsvDelay } return 0 } func (x *ChannelConstraints) GetChanReserveSat() uint64 { if x != nil { return x.ChanReserveSat } return 0 } func (x *ChannelConstraints) GetDustLimitSat() uint64 { if x != nil { return x.DustLimitSat } return 0 } func (x *ChannelConstraints) GetMaxPendingAmtMsat() uint64 { if x != nil { return x.MaxPendingAmtMsat } return 0 } func (x *ChannelConstraints) GetMinHtlcMsat() uint64 { if x != nil { return x.MinHtlcMsat } return 0 } func (x *ChannelConstraints) GetMaxAcceptedHtlcs() uint32 { if x != nil { return x.MaxAcceptedHtlcs } return 0 } type Channel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Whether this channel is active or not Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty"` // The identity pubkey of the remote node RemotePubkey string `protobuf:"bytes,2,opt,name=remote_pubkey,json=remotePubkey,proto3" json:"remote_pubkey,omitempty"` // //The outpoint (txid:index) of the funding transaction. With this value, Bob //will be able to generate a signature for Alice's version of the commitment //transaction. ChannelPoint string `protobuf:"bytes,3,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChanId uint64 `protobuf:"varint,4,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // The total amount of funds held in this channel Capacity int64 `protobuf:"varint,5,opt,name=capacity,proto3" json:"capacity,omitempty"` // This node's current balance in this channel LocalBalance int64 `protobuf:"varint,6,opt,name=local_balance,json=localBalance,proto3" json:"local_balance,omitempty"` // The counterparty's current balance in this channel RemoteBalance int64 `protobuf:"varint,7,opt,name=remote_balance,json=remoteBalance,proto3" json:"remote_balance,omitempty"` // //The amount calculated to be paid in fees for the current set of commitment //transactions. The fee amount is persisted with the channel in order to //allow the fee amount to be removed and recalculated with each channel state //update, including updates that happen after a system restart. CommitFee int64 `protobuf:"varint,8,opt,name=commit_fee,json=commitFee,proto3" json:"commit_fee,omitempty"` // The weight of the commitment transaction CommitWeight int64 `protobuf:"varint,9,opt,name=commit_weight,json=commitWeight,proto3" json:"commit_weight,omitempty"` // //The required number of satoshis per kilo-weight that the requester will pay //at all times, for both the funding transaction and commitment transaction. //This value can later be updated once the channel is open. FeePerKw int64 `protobuf:"varint,10,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` // The unsettled balance in this channel UnsettledBalance int64 `protobuf:"varint,11,opt,name=unsettled_balance,json=unsettledBalance,proto3" json:"unsettled_balance,omitempty"` // //The total number of satoshis we've sent within this channel. TotalSatoshisSent int64 `protobuf:"varint,12,opt,name=total_satoshis_sent,json=totalSatoshisSent,proto3" json:"total_satoshis_sent,omitempty"` // //The total number of satoshis we've received within this channel. TotalSatoshisReceived int64 `protobuf:"varint,13,opt,name=total_satoshis_received,json=totalSatoshisReceived,proto3" json:"total_satoshis_received,omitempty"` // //The total number of updates conducted within this channel. NumUpdates uint64 `protobuf:"varint,14,opt,name=num_updates,json=numUpdates,proto3" json:"num_updates,omitempty"` // //The list of active, uncleared HTLCs currently pending within the channel. PendingHtlcs []*HTLC `protobuf:"bytes,15,rep,name=pending_htlcs,json=pendingHtlcs,proto3" json:"pending_htlcs,omitempty"` // //Deprecated. The CSV delay expressed in relative blocks. If the channel is //force closed, we will need to wait for this many blocks before we can regain //our funds. // // Deprecated: Do not use. CsvDelay uint32 `protobuf:"varint,16,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` // Whether this channel is advertised to the network or not. Private bool `protobuf:"varint,17,opt,name=private,proto3" json:"private,omitempty"` // True if we were the ones that created the channel. Initiator bool `protobuf:"varint,18,opt,name=initiator,proto3" json:"initiator,omitempty"` // A set of flags showing the current state of the channel. ChanStatusFlags string `protobuf:"bytes,19,opt,name=chan_status_flags,json=chanStatusFlags,proto3" json:"chan_status_flags,omitempty"` // Deprecated. The minimum satoshis this node is required to reserve in its // balance. // // Deprecated: Do not use. LocalChanReserveSat int64 `protobuf:"varint,20,opt,name=local_chan_reserve_sat,json=localChanReserveSat,proto3" json:"local_chan_reserve_sat,omitempty"` // //Deprecated. The minimum satoshis the other node is required to reserve in //its balance. // // Deprecated: Do not use. RemoteChanReserveSat int64 `protobuf:"varint,21,opt,name=remote_chan_reserve_sat,json=remoteChanReserveSat,proto3" json:"remote_chan_reserve_sat,omitempty"` // Deprecated. Use commitment_type. // // Deprecated: Do not use. StaticRemoteKey bool `protobuf:"varint,22,opt,name=static_remote_key,json=staticRemoteKey,proto3" json:"static_remote_key,omitempty"` // The commitment type used by this channel. CommitmentType CommitmentType `protobuf:"varint,26,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` // //The number of seconds that the channel has been monitored by the channel //scoring system. Scores are currently not persisted, so this value may be //less than the lifetime of the channel [EXPERIMENTAL]. Lifetime int64 `protobuf:"varint,23,opt,name=lifetime,proto3" json:"lifetime,omitempty"` // //The number of seconds that the remote peer has been observed as being online //by the channel scoring system over the lifetime of the channel //[EXPERIMENTAL]. Uptime int64 `protobuf:"varint,24,opt,name=uptime,proto3" json:"uptime,omitempty"` // //Close address is the address that we will enforce payout to on cooperative //close if the channel was opened utilizing option upfront shutdown. This //value can be set on channel open by setting close_address in an open channel //request. If this value is not set, you can still choose a payout address by //cooperatively closing with the delivery_address field set. CloseAddress string `protobuf:"bytes,25,opt,name=close_address,json=closeAddress,proto3" json:"close_address,omitempty"` // //The amount that the initiator of the channel optionally pushed to the remote //party on channel open. This amount will be zero if the channel initiator did //not push any funds to the remote peer. If the initiator field is true, we //pushed this amount to our peer, if it is false, the remote peer pushed this //amount to us. PushAmountSat uint64 `protobuf:"varint,27,opt,name=push_amount_sat,json=pushAmountSat,proto3" json:"push_amount_sat,omitempty"` // //This uint32 indicates if this channel is to be considered 'frozen'. A //frozen channel doest not allow a cooperative channel close by the //initiator. The thaw_height is the height that this restriction stops //applying to the channel. This field is optional, not setting it or using a //value of zero will mean the channel has no additional restrictions. The //height can be interpreted in two ways: as a relative height if the value is //less than 500,000, or as an absolute height otherwise. ThawHeight uint32 `protobuf:"varint,28,opt,name=thaw_height,json=thawHeight,proto3" json:"thaw_height,omitempty"` // List constraints for the local node. LocalConstraints *ChannelConstraints `protobuf:"bytes,29,opt,name=local_constraints,json=localConstraints,proto3" json:"local_constraints,omitempty"` // List constraints for the remote node. RemoteConstraints *ChannelConstraints `protobuf:"bytes,30,opt,name=remote_constraints,json=remoteConstraints,proto3" json:"remote_constraints,omitempty"` } func (x *Channel) Reset() { *x = Channel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Channel) String() string { return protoimpl.X.MessageStringOf(x) } func (*Channel) ProtoMessage() {} func (x *Channel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Channel.ProtoReflect.Descriptor instead. func (*Channel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{37} } func (x *Channel) GetActive() bool { if x != nil { return x.Active } return false } func (x *Channel) GetRemotePubkey() string { if x != nil { return x.RemotePubkey } return "" } func (x *Channel) GetChannelPoint() string { if x != nil { return x.ChannelPoint } return "" } func (x *Channel) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *Channel) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *Channel) GetLocalBalance() int64 { if x != nil { return x.LocalBalance } return 0 } func (x *Channel) GetRemoteBalance() int64 { if x != nil { return x.RemoteBalance } return 0 } func (x *Channel) GetCommitFee() int64 { if x != nil { return x.CommitFee } return 0 } func (x *Channel) GetCommitWeight() int64 { if x != nil { return x.CommitWeight } return 0 } func (x *Channel) GetFeePerKw() int64 { if x != nil { return x.FeePerKw } return 0 } func (x *Channel) GetUnsettledBalance() int64 { if x != nil { return x.UnsettledBalance } return 0 } func (x *Channel) GetTotalSatoshisSent() int64 { if x != nil { return x.TotalSatoshisSent } return 0 } func (x *Channel) GetTotalSatoshisReceived() int64 { if x != nil { return x.TotalSatoshisReceived } return 0 } func (x *Channel) GetNumUpdates() uint64 { if x != nil { return x.NumUpdates } return 0 } func (x *Channel) GetPendingHtlcs() []*HTLC { if x != nil { return x.PendingHtlcs } return nil } // Deprecated: Do not use. func (x *Channel) GetCsvDelay() uint32 { if x != nil { return x.CsvDelay } return 0 } func (x *Channel) GetPrivate() bool { if x != nil { return x.Private } return false } func (x *Channel) GetInitiator() bool { if x != nil { return x.Initiator } return false } func (x *Channel) GetChanStatusFlags() string { if x != nil { return x.ChanStatusFlags } return "" } // Deprecated: Do not use. func (x *Channel) GetLocalChanReserveSat() int64 { if x != nil { return x.LocalChanReserveSat } return 0 } // Deprecated: Do not use. func (x *Channel) GetRemoteChanReserveSat() int64 { if x != nil { return x.RemoteChanReserveSat } return 0 } // Deprecated: Do not use. func (x *Channel) GetStaticRemoteKey() bool { if x != nil { return x.StaticRemoteKey } return false } func (x *Channel) GetCommitmentType() CommitmentType { if x != nil { return x.CommitmentType } return CommitmentType_UNKNOWN_COMMITMENT_TYPE } func (x *Channel) GetLifetime() int64 { if x != nil { return x.Lifetime } return 0 } func (x *Channel) GetUptime() int64 { if x != nil { return x.Uptime } return 0 } func (x *Channel) GetCloseAddress() string { if x != nil { return x.CloseAddress } return "" } func (x *Channel) GetPushAmountSat() uint64 { if x != nil { return x.PushAmountSat } return 0 } func (x *Channel) GetThawHeight() uint32 { if x != nil { return x.ThawHeight } return 0 } func (x *Channel) GetLocalConstraints() *ChannelConstraints { if x != nil { return x.LocalConstraints } return nil } func (x *Channel) GetRemoteConstraints() *ChannelConstraints { if x != nil { return x.RemoteConstraints } return nil } type ListChannelsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields ActiveOnly bool `protobuf:"varint,1,opt,name=active_only,json=activeOnly,proto3" json:"active_only,omitempty"` InactiveOnly bool `protobuf:"varint,2,opt,name=inactive_only,json=inactiveOnly,proto3" json:"inactive_only,omitempty"` PublicOnly bool `protobuf:"varint,3,opt,name=public_only,json=publicOnly,proto3" json:"public_only,omitempty"` PrivateOnly bool `protobuf:"varint,4,opt,name=private_only,json=privateOnly,proto3" json:"private_only,omitempty"` // //Filters the response for channels with a target peer's pubkey. If peer is //empty, all channels will be returned. Peer []byte `protobuf:"bytes,5,opt,name=peer,proto3" json:"peer,omitempty"` } func (x *ListChannelsRequest) Reset() { *x = ListChannelsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListChannelsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListChannelsRequest) ProtoMessage() {} func (x *ListChannelsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListChannelsRequest.ProtoReflect.Descriptor instead. func (*ListChannelsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{38} } func (x *ListChannelsRequest) GetActiveOnly() bool { if x != nil { return x.ActiveOnly } return false } func (x *ListChannelsRequest) GetInactiveOnly() bool { if x != nil { return x.InactiveOnly } return false } func (x *ListChannelsRequest) GetPublicOnly() bool { if x != nil { return x.PublicOnly } return false } func (x *ListChannelsRequest) GetPrivateOnly() bool { if x != nil { return x.PrivateOnly } return false } func (x *ListChannelsRequest) GetPeer() []byte { if x != nil { return x.Peer } return nil } type ListChannelsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of active channels Channels []*Channel `protobuf:"bytes,11,rep,name=channels,proto3" json:"channels,omitempty"` } func (x *ListChannelsResponse) Reset() { *x = ListChannelsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListChannelsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListChannelsResponse) ProtoMessage() {} func (x *ListChannelsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListChannelsResponse.ProtoReflect.Descriptor instead. func (*ListChannelsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{39} } func (x *ListChannelsResponse) GetChannels() []*Channel { if x != nil { return x.Channels } return nil } type ChannelCloseSummary struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The outpoint (txid:index) of the funding transaction. ChannelPoint string `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` // The unique channel ID for the channel. ChanId uint64 `protobuf:"varint,2,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // The hash of the genesis block that this channel resides within. ChainHash string `protobuf:"bytes,3,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` // The txid of the transaction which ultimately closed this channel. ClosingTxHash string `protobuf:"bytes,4,opt,name=closing_tx_hash,json=closingTxHash,proto3" json:"closing_tx_hash,omitempty"` // Public key of the remote peer that we formerly had a channel with. RemotePubkey string `protobuf:"bytes,5,opt,name=remote_pubkey,json=remotePubkey,proto3" json:"remote_pubkey,omitempty"` // Total capacity of the channel. Capacity int64 `protobuf:"varint,6,opt,name=capacity,proto3" json:"capacity,omitempty"` // Height at which the funding transaction was spent. CloseHeight uint32 `protobuf:"varint,7,opt,name=close_height,json=closeHeight,proto3" json:"close_height,omitempty"` // Settled balance at the time of channel closure SettledBalance int64 `protobuf:"varint,8,opt,name=settled_balance,json=settledBalance,proto3" json:"settled_balance,omitempty"` // The sum of all the time-locked outputs at the time of channel closure TimeLockedBalance int64 `protobuf:"varint,9,opt,name=time_locked_balance,json=timeLockedBalance,proto3" json:"time_locked_balance,omitempty"` // Details on how the channel was closed. CloseType ChannelCloseSummary_ClosureType `protobuf:"varint,10,opt,name=close_type,json=closeType,proto3,enum=lnrpc.ChannelCloseSummary_ClosureType" json:"close_type,omitempty"` // //Open initiator is the party that initiated opening the channel. Note that //this value may be unknown if the channel was closed before we migrated to //store open channel information after close. OpenInitiator Initiator `protobuf:"varint,11,opt,name=open_initiator,json=openInitiator,proto3,enum=lnrpc.Initiator" json:"open_initiator,omitempty"` // //Close initiator indicates which party initiated the close. This value will //be unknown for channels that were cooperatively closed before we started //tracking cooperative close initiators. Note that this indicates which party //initiated a close, and it is possible for both to initiate cooperative or //force closes, although only one party's close will be confirmed on chain. CloseInitiator Initiator `protobuf:"varint,12,opt,name=close_initiator,json=closeInitiator,proto3,enum=lnrpc.Initiator" json:"close_initiator,omitempty"` Resolutions []*Resolution `protobuf:"bytes,13,rep,name=resolutions,proto3" json:"resolutions,omitempty"` } func (x *ChannelCloseSummary) Reset() { *x = ChannelCloseSummary{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelCloseSummary) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelCloseSummary) ProtoMessage() {} func (x *ChannelCloseSummary) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelCloseSummary.ProtoReflect.Descriptor instead. func (*ChannelCloseSummary) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{40} } func (x *ChannelCloseSummary) GetChannelPoint() string { if x != nil { return x.ChannelPoint } return "" } func (x *ChannelCloseSummary) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *ChannelCloseSummary) GetChainHash() string { if x != nil { return x.ChainHash } return "" } func (x *ChannelCloseSummary) GetClosingTxHash() string { if x != nil { return x.ClosingTxHash } return "" } func (x *ChannelCloseSummary) GetRemotePubkey() string { if x != nil { return x.RemotePubkey } return "" } func (x *ChannelCloseSummary) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *ChannelCloseSummary) GetCloseHeight() uint32 { if x != nil { return x.CloseHeight } return 0 } func (x *ChannelCloseSummary) GetSettledBalance() int64 { if x != nil { return x.SettledBalance } return 0 } func (x *ChannelCloseSummary) GetTimeLockedBalance() int64 { if x != nil { return x.TimeLockedBalance } return 0 } func (x *ChannelCloseSummary) GetCloseType() ChannelCloseSummary_ClosureType { if x != nil { return x.CloseType } return ChannelCloseSummary_COOPERATIVE_CLOSE } func (x *ChannelCloseSummary) GetOpenInitiator() Initiator { if x != nil { return x.OpenInitiator } return Initiator_INITIATOR_UNKNOWN } func (x *ChannelCloseSummary) GetCloseInitiator() Initiator { if x != nil { return x.CloseInitiator } return Initiator_INITIATOR_UNKNOWN } func (x *ChannelCloseSummary) GetResolutions() []*Resolution { if x != nil { return x.Resolutions } return nil } type Resolution struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The type of output we are resolving. ResolutionType ResolutionType `protobuf:"varint,1,opt,name=resolution_type,json=resolutionType,proto3,enum=lnrpc.ResolutionType" json:"resolution_type,omitempty"` // The outcome of our on chain action that resolved the outpoint. Outcome ResolutionOutcome `protobuf:"varint,2,opt,name=outcome,proto3,enum=lnrpc.ResolutionOutcome" json:"outcome,omitempty"` // The outpoint that was spent by the resolution. Outpoint *OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // The amount that was claimed by the resolution. AmountSat uint64 `protobuf:"varint,4,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"` // The hex-encoded transaction ID of the sweep transaction that spent the // output. SweepTxid string `protobuf:"bytes,5,opt,name=sweep_txid,json=sweepTxid,proto3" json:"sweep_txid,omitempty"` } func (x *Resolution) Reset() { *x = Resolution{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Resolution) String() string { return protoimpl.X.MessageStringOf(x) } func (*Resolution) ProtoMessage() {} func (x *Resolution) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Resolution.ProtoReflect.Descriptor instead. func (*Resolution) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{41} } func (x *Resolution) GetResolutionType() ResolutionType { if x != nil { return x.ResolutionType } return ResolutionType_TYPE_UNKNOWN } func (x *Resolution) GetOutcome() ResolutionOutcome { if x != nil { return x.Outcome } return ResolutionOutcome_OUTCOME_UNKNOWN } func (x *Resolution) GetOutpoint() *OutPoint { if x != nil { return x.Outpoint } return nil } func (x *Resolution) GetAmountSat() uint64 { if x != nil { return x.AmountSat } return 0 } func (x *Resolution) GetSweepTxid() string { if x != nil { return x.SweepTxid } return "" } type ClosedChannelsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Cooperative bool `protobuf:"varint,1,opt,name=cooperative,proto3" json:"cooperative,omitempty"` LocalForce bool `protobuf:"varint,2,opt,name=local_force,json=localForce,proto3" json:"local_force,omitempty"` RemoteForce bool `protobuf:"varint,3,opt,name=remote_force,json=remoteForce,proto3" json:"remote_force,omitempty"` Breach bool `protobuf:"varint,4,opt,name=breach,proto3" json:"breach,omitempty"` FundingCanceled bool `protobuf:"varint,5,opt,name=funding_canceled,json=fundingCanceled,proto3" json:"funding_canceled,omitempty"` Abandoned bool `protobuf:"varint,6,opt,name=abandoned,proto3" json:"abandoned,omitempty"` } func (x *ClosedChannelsRequest) Reset() { *x = ClosedChannelsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ClosedChannelsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ClosedChannelsRequest) ProtoMessage() {} func (x *ClosedChannelsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ClosedChannelsRequest.ProtoReflect.Descriptor instead. func (*ClosedChannelsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{42} } func (x *ClosedChannelsRequest) GetCooperative() bool { if x != nil { return x.Cooperative } return false } func (x *ClosedChannelsRequest) GetLocalForce() bool { if x != nil { return x.LocalForce } return false } func (x *ClosedChannelsRequest) GetRemoteForce() bool { if x != nil { return x.RemoteForce } return false } func (x *ClosedChannelsRequest) GetBreach() bool { if x != nil { return x.Breach } return false } func (x *ClosedChannelsRequest) GetFundingCanceled() bool { if x != nil { return x.FundingCanceled } return false } func (x *ClosedChannelsRequest) GetAbandoned() bool { if x != nil { return x.Abandoned } return false } type ClosedChannelsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Channels []*ChannelCloseSummary `protobuf:"bytes,1,rep,name=channels,proto3" json:"channels,omitempty"` } func (x *ClosedChannelsResponse) Reset() { *x = ClosedChannelsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ClosedChannelsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ClosedChannelsResponse) ProtoMessage() {} func (x *ClosedChannelsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ClosedChannelsResponse.ProtoReflect.Descriptor instead. func (*ClosedChannelsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{43} } func (x *ClosedChannelsResponse) GetChannels() []*ChannelCloseSummary { if x != nil { return x.Channels } return nil } type Peer struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The identity pubkey of the peer PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` // Network address of the peer; eg `127.0.0.1:10011` Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"` // Bytes of data transmitted to this peer BytesSent uint64 `protobuf:"varint,4,opt,name=bytes_sent,json=bytesSent,proto3" json:"bytes_sent,omitempty"` // Bytes of data transmitted from this peer BytesRecv uint64 `protobuf:"varint,5,opt,name=bytes_recv,json=bytesRecv,proto3" json:"bytes_recv,omitempty"` // Satoshis sent to this peer SatSent int64 `protobuf:"varint,6,opt,name=sat_sent,json=satSent,proto3" json:"sat_sent,omitempty"` // Satoshis received from this peer SatRecv int64 `protobuf:"varint,7,opt,name=sat_recv,json=satRecv,proto3" json:"sat_recv,omitempty"` // A channel is inbound if the counterparty initiated the channel Inbound bool `protobuf:"varint,8,opt,name=inbound,proto3" json:"inbound,omitempty"` // Ping time to this peer PingTime int64 `protobuf:"varint,9,opt,name=ping_time,json=pingTime,proto3" json:"ping_time,omitempty"` // The type of sync we are currently performing with this peer. SyncType Peer_SyncType `protobuf:"varint,10,opt,name=sync_type,json=syncType,proto3,enum=lnrpc.Peer_SyncType" json:"sync_type,omitempty"` // Features advertised by the remote peer in their init message. Features map[uint32]*Feature `protobuf:"bytes,11,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // //The latest errors received from our peer with timestamps, limited to the 10 //most recent errors. These errors are tracked across peer connections, but //are not persisted across lnd restarts. Note that these errors are only //stored for peers that we have channels open with, to prevent peers from //spamming us with errors at no cost. Errors []*TimestampedError `protobuf:"bytes,12,rep,name=errors,proto3" json:"errors,omitempty"` // //The number of times we have recorded this peer going offline or coming //online, recorded across restarts. Note that this value is decreased over //time if the peer has not recently flapped, so that we can forgive peers //with historically high flap counts. FlapCount int32 `protobuf:"varint,13,opt,name=flap_count,json=flapCount,proto3" json:"flap_count,omitempty"` // //The timestamp of the last flap we observed for this peer. If this value is //zero, we have not observed any flaps for this peer. LastFlapNs int64 `protobuf:"varint,14,opt,name=last_flap_ns,json=lastFlapNs,proto3" json:"last_flap_ns,omitempty"` // //The last ping payload the peer has sent to us. LastPingPayload []byte `protobuf:"bytes,15,opt,name=last_ping_payload,json=lastPingPayload,proto3" json:"last_ping_payload,omitempty"` } func (x *Peer) Reset() { *x = Peer{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Peer) String() string { return protoimpl.X.MessageStringOf(x) } func (*Peer) ProtoMessage() {} func (x *Peer) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Peer.ProtoReflect.Descriptor instead. func (*Peer) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{44} } func (x *Peer) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *Peer) GetAddress() string { if x != nil { return x.Address } return "" } func (x *Peer) GetBytesSent() uint64 { if x != nil { return x.BytesSent } return 0 } func (x *Peer) GetBytesRecv() uint64 { if x != nil { return x.BytesRecv } return 0 } func (x *Peer) GetSatSent() int64 { if x != nil { return x.SatSent } return 0 } func (x *Peer) GetSatRecv() int64 { if x != nil { return x.SatRecv } return 0 } func (x *Peer) GetInbound() bool { if x != nil { return x.Inbound } return false } func (x *Peer) GetPingTime() int64 { if x != nil { return x.PingTime } return 0 } func (x *Peer) GetSyncType() Peer_SyncType { if x != nil { return x.SyncType } return Peer_UNKNOWN_SYNC } func (x *Peer) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } func (x *Peer) GetErrors() []*TimestampedError { if x != nil { return x.Errors } return nil } func (x *Peer) GetFlapCount() int32 { if x != nil { return x.FlapCount } return 0 } func (x *Peer) GetLastFlapNs() int64 { if x != nil { return x.LastFlapNs } return 0 } func (x *Peer) GetLastPingPayload() []byte { if x != nil { return x.LastPingPayload } return nil } type TimestampedError struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The unix timestamp in seconds when the error occurred. Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The string representation of the error sent by our peer. Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` } func (x *TimestampedError) Reset() { *x = TimestampedError{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *TimestampedError) String() string { return protoimpl.X.MessageStringOf(x) } func (*TimestampedError) ProtoMessage() {} func (x *TimestampedError) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use TimestampedError.ProtoReflect.Descriptor instead. func (*TimestampedError) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{45} } func (x *TimestampedError) GetTimestamp() uint64 { if x != nil { return x.Timestamp } return 0 } func (x *TimestampedError) GetError() string { if x != nil { return x.Error } return "" } type ListPeersRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //If true, only the last error that our peer sent us will be returned with //the peer's information, rather than the full set of historic errors we have //stored. LatestError bool `protobuf:"varint,1,opt,name=latest_error,json=latestError,proto3" json:"latest_error,omitempty"` } func (x *ListPeersRequest) Reset() { *x = ListPeersRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPeersRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPeersRequest) ProtoMessage() {} func (x *ListPeersRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPeersRequest.ProtoReflect.Descriptor instead. func (*ListPeersRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{46} } func (x *ListPeersRequest) GetLatestError() bool { if x != nil { return x.LatestError } return false } type ListPeersResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of currently connected peers Peers []*Peer `protobuf:"bytes,1,rep,name=peers,proto3" json:"peers,omitempty"` } func (x *ListPeersResponse) Reset() { *x = ListPeersResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPeersResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPeersResponse) ProtoMessage() {} func (x *ListPeersResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPeersResponse.ProtoReflect.Descriptor instead. func (*ListPeersResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{47} } func (x *ListPeersResponse) GetPeers() []*Peer { if x != nil { return x.Peers } return nil } type PeerEventSubscription struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *PeerEventSubscription) Reset() { *x = PeerEventSubscription{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PeerEventSubscription) String() string { return protoimpl.X.MessageStringOf(x) } func (*PeerEventSubscription) ProtoMessage() {} func (x *PeerEventSubscription) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PeerEventSubscription.ProtoReflect.Descriptor instead. func (*PeerEventSubscription) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{48} } type PeerEvent struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The identity pubkey of the peer. PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` Type PeerEvent_EventType `protobuf:"varint,2,opt,name=type,proto3,enum=lnrpc.PeerEvent_EventType" json:"type,omitempty"` } func (x *PeerEvent) Reset() { *x = PeerEvent{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PeerEvent) String() string { return protoimpl.X.MessageStringOf(x) } func (*PeerEvent) ProtoMessage() {} func (x *PeerEvent) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PeerEvent.ProtoReflect.Descriptor instead. func (*PeerEvent) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{49} } func (x *PeerEvent) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *PeerEvent) GetType() PeerEvent_EventType { if x != nil { return x.Type } return PeerEvent_PEER_ONLINE } type GetInfoRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *GetInfoRequest) Reset() { *x = GetInfoRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GetInfoRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*GetInfoRequest) ProtoMessage() {} func (x *GetInfoRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GetInfoRequest.ProtoReflect.Descriptor instead. func (*GetInfoRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{50} } type GetInfoResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The version of the LND software that the node is running. Version string `protobuf:"bytes,14,opt,name=version,proto3" json:"version,omitempty"` // The SHA1 commit hash that the daemon is compiled with. CommitHash string `protobuf:"bytes,20,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"` // The identity pubkey of the current node. IdentityPubkey string `protobuf:"bytes,1,opt,name=identity_pubkey,json=identityPubkey,proto3" json:"identity_pubkey,omitempty"` // If applicable, the alias of the current node, e.g. "bob" Alias string `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"` // The color of the current node in hex code format Color string `protobuf:"bytes,17,opt,name=color,proto3" json:"color,omitempty"` // Number of pending channels NumPendingChannels uint32 `protobuf:"varint,3,opt,name=num_pending_channels,json=numPendingChannels,proto3" json:"num_pending_channels,omitempty"` // Number of active channels NumActiveChannels uint32 `protobuf:"varint,4,opt,name=num_active_channels,json=numActiveChannels,proto3" json:"num_active_channels,omitempty"` // Number of inactive channels NumInactiveChannels uint32 `protobuf:"varint,15,opt,name=num_inactive_channels,json=numInactiveChannels,proto3" json:"num_inactive_channels,omitempty"` // Number of peers NumPeers uint32 `protobuf:"varint,5,opt,name=num_peers,json=numPeers,proto3" json:"num_peers,omitempty"` // The node's current view of the height of the best block BlockHeight uint32 `protobuf:"varint,6,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` // The node's current view of the hash of the best block BlockHash string `protobuf:"bytes,8,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` // Timestamp of the block best known to the wallet BestHeaderTimestamp int64 `protobuf:"varint,13,opt,name=best_header_timestamp,json=bestHeaderTimestamp,proto3" json:"best_header_timestamp,omitempty"` // Whether the wallet's view is synced to the main chain SyncedToChain bool `protobuf:"varint,9,opt,name=synced_to_chain,json=syncedToChain,proto3" json:"synced_to_chain,omitempty"` // Whether we consider ourselves synced with the public channel graph. SyncedToGraph bool `protobuf:"varint,18,opt,name=synced_to_graph,json=syncedToGraph,proto3" json:"synced_to_graph,omitempty"` // //Whether the current node is connected to testnet. This field is //deprecated and the network field should be used instead // // Deprecated: Do not use. Testnet bool `protobuf:"varint,10,opt,name=testnet,proto3" json:"testnet,omitempty"` // A list of active chains the node is connected to Chains []*Chain `protobuf:"bytes,16,rep,name=chains,proto3" json:"chains,omitempty"` // The URIs of the current node. Uris []string `protobuf:"bytes,12,rep,name=uris,proto3" json:"uris,omitempty"` // //Features that our node has advertised in our init message, node //announcements and invoices. Features map[uint32]*Feature `protobuf:"bytes,19,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *GetInfoResponse) Reset() { *x = GetInfoResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GetInfoResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*GetInfoResponse) ProtoMessage() {} func (x *GetInfoResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GetInfoResponse.ProtoReflect.Descriptor instead. func (*GetInfoResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{51} } func (x *GetInfoResponse) GetVersion() string { if x != nil { return x.Version } return "" } func (x *GetInfoResponse) GetCommitHash() string { if x != nil { return x.CommitHash } return "" } func (x *GetInfoResponse) GetIdentityPubkey() string { if x != nil { return x.IdentityPubkey } return "" } func (x *GetInfoResponse) GetAlias() string { if x != nil { return x.Alias } return "" } func (x *GetInfoResponse) GetColor() string { if x != nil { return x.Color } return "" } func (x *GetInfoResponse) GetNumPendingChannels() uint32 { if x != nil { return x.NumPendingChannels } return 0 } func (x *GetInfoResponse) GetNumActiveChannels() uint32 { if x != nil { return x.NumActiveChannels } return 0 } func (x *GetInfoResponse) GetNumInactiveChannels() uint32 { if x != nil { return x.NumInactiveChannels } return 0 } func (x *GetInfoResponse) GetNumPeers() uint32 { if x != nil { return x.NumPeers } return 0 } func (x *GetInfoResponse) GetBlockHeight() uint32 { if x != nil { return x.BlockHeight } return 0 } func (x *GetInfoResponse) GetBlockHash() string { if x != nil { return x.BlockHash } return "" } func (x *GetInfoResponse) GetBestHeaderTimestamp() int64 { if x != nil { return x.BestHeaderTimestamp } return 0 } func (x *GetInfoResponse) GetSyncedToChain() bool { if x != nil { return x.SyncedToChain } return false } func (x *GetInfoResponse) GetSyncedToGraph() bool { if x != nil { return x.SyncedToGraph } return false } // Deprecated: Do not use. func (x *GetInfoResponse) GetTestnet() bool { if x != nil { return x.Testnet } return false } func (x *GetInfoResponse) GetChains() []*Chain { if x != nil { return x.Chains } return nil } func (x *GetInfoResponse) GetUris() []string { if x != nil { return x.Uris } return nil } func (x *GetInfoResponse) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } type GetRecoveryInfoRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *GetRecoveryInfoRequest) Reset() { *x = GetRecoveryInfoRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GetRecoveryInfoRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*GetRecoveryInfoRequest) ProtoMessage() {} func (x *GetRecoveryInfoRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GetRecoveryInfoRequest.ProtoReflect.Descriptor instead. func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{52} } type GetRecoveryInfoResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Whether the wallet is in recovery mode RecoveryMode bool `protobuf:"varint,1,opt,name=recovery_mode,json=recoveryMode,proto3" json:"recovery_mode,omitempty"` // Whether the wallet recovery progress is finished RecoveryFinished bool `protobuf:"varint,2,opt,name=recovery_finished,json=recoveryFinished,proto3" json:"recovery_finished,omitempty"` // The recovery progress, ranging from 0 to 1. Progress float64 `protobuf:"fixed64,3,opt,name=progress,proto3" json:"progress,omitempty"` } func (x *GetRecoveryInfoResponse) Reset() { *x = GetRecoveryInfoResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GetRecoveryInfoResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*GetRecoveryInfoResponse) ProtoMessage() {} func (x *GetRecoveryInfoResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GetRecoveryInfoResponse.ProtoReflect.Descriptor instead. func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{53} } func (x *GetRecoveryInfoResponse) GetRecoveryMode() bool { if x != nil { return x.RecoveryMode } return false } func (x *GetRecoveryInfoResponse) GetRecoveryFinished() bool { if x != nil { return x.RecoveryFinished } return false } func (x *GetRecoveryInfoResponse) GetProgress() float64 { if x != nil { return x.Progress } return 0 } type Chain struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The blockchain the node is on (eg bitcoin, litecoin) Chain string `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain,omitempty"` // The network the node is on (eg regtest, testnet, mainnet) Network string `protobuf:"bytes,2,opt,name=network,proto3" json:"network,omitempty"` } func (x *Chain) Reset() { *x = Chain{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Chain) String() string { return protoimpl.X.MessageStringOf(x) } func (*Chain) ProtoMessage() {} func (x *Chain) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Chain.ProtoReflect.Descriptor instead. func (*Chain) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{54} } func (x *Chain) GetChain() string { if x != nil { return x.Chain } return "" } func (x *Chain) GetNetwork() string { if x != nil { return x.Network } return "" } type ConfirmationUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields BlockSha []byte `protobuf:"bytes,1,opt,name=block_sha,json=blockSha,proto3" json:"block_sha,omitempty"` BlockHeight int32 `protobuf:"varint,2,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` NumConfsLeft uint32 `protobuf:"varint,3,opt,name=num_confs_left,json=numConfsLeft,proto3" json:"num_confs_left,omitempty"` } func (x *ConfirmationUpdate) Reset() { *x = ConfirmationUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ConfirmationUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ConfirmationUpdate) ProtoMessage() {} func (x *ConfirmationUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ConfirmationUpdate.ProtoReflect.Descriptor instead. func (*ConfirmationUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{55} } func (x *ConfirmationUpdate) GetBlockSha() []byte { if x != nil { return x.BlockSha } return nil } func (x *ConfirmationUpdate) GetBlockHeight() int32 { if x != nil { return x.BlockHeight } return 0 } func (x *ConfirmationUpdate) GetNumConfsLeft() uint32 { if x != nil { return x.NumConfsLeft } return 0 } type ChannelOpenUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` } func (x *ChannelOpenUpdate) Reset() { *x = ChannelOpenUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelOpenUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelOpenUpdate) ProtoMessage() {} func (x *ChannelOpenUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelOpenUpdate.ProtoReflect.Descriptor instead. func (*ChannelOpenUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{56} } func (x *ChannelOpenUpdate) GetChannelPoint() *ChannelPoint { if x != nil { return x.ChannelPoint } return nil } type ChannelCloseUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields ClosingTxid []byte `protobuf:"bytes,1,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` Success bool `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"` } func (x *ChannelCloseUpdate) Reset() { *x = ChannelCloseUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelCloseUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelCloseUpdate) ProtoMessage() {} func (x *ChannelCloseUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelCloseUpdate.ProtoReflect.Descriptor instead. func (*ChannelCloseUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{57} } func (x *ChannelCloseUpdate) GetClosingTxid() []byte { if x != nil { return x.ClosingTxid } return nil } func (x *ChannelCloseUpdate) GetSuccess() bool { if x != nil { return x.Success } return false } type CloseChannelRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The outpoint (txid:index) of the funding transaction. With this value, Bob //will be able to generate a signature for Alice's version of the commitment //transaction. ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` // If true, then the channel will be closed forcibly. This means the // current commitment transaction will be signed and broadcast. Force bool `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"` // The target number of blocks that the closure transaction should be // confirmed by. TargetConf int32 `protobuf:"varint,3,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // Deprecated, use sat_per_vbyte. // A manual fee rate set in sat/vbyte that should be used when crafting the // closure transaction. // // Deprecated: Do not use. SatPerByte int64 `protobuf:"varint,4,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // //An optional address to send funds to in the case of a cooperative close. //If the channel was opened with an upfront shutdown script and this field //is set, the request to close will fail because the channel must pay out //to the upfront shutdown addresss. DeliveryAddress string `protobuf:"bytes,5,opt,name=delivery_address,json=deliveryAddress,proto3" json:"delivery_address,omitempty"` // A manual fee rate set in sat/vbyte that should be used when crafting the // closure transaction. SatPerVbyte uint64 `protobuf:"varint,6,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` } func (x *CloseChannelRequest) Reset() { *x = CloseChannelRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *CloseChannelRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*CloseChannelRequest) ProtoMessage() {} func (x *CloseChannelRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use CloseChannelRequest.ProtoReflect.Descriptor instead. func (*CloseChannelRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{58} } func (x *CloseChannelRequest) GetChannelPoint() *ChannelPoint { if x != nil { return x.ChannelPoint } return nil } func (x *CloseChannelRequest) GetForce() bool { if x != nil { return x.Force } return false } func (x *CloseChannelRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } // Deprecated: Do not use. func (x *CloseChannelRequest) GetSatPerByte() int64 { if x != nil { return x.SatPerByte } return 0 } func (x *CloseChannelRequest) GetDeliveryAddress() string { if x != nil { return x.DeliveryAddress } return "" } func (x *CloseChannelRequest) GetSatPerVbyte() uint64 { if x != nil { return x.SatPerVbyte } return 0 } type CloseStatusUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Update: // *CloseStatusUpdate_ClosePending // *CloseStatusUpdate_ChanClose Update isCloseStatusUpdate_Update `protobuf_oneof:"update"` } func (x *CloseStatusUpdate) Reset() { *x = CloseStatusUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *CloseStatusUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*CloseStatusUpdate) ProtoMessage() {} func (x *CloseStatusUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use CloseStatusUpdate.ProtoReflect.Descriptor instead. func (*CloseStatusUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{59} } func (m *CloseStatusUpdate) GetUpdate() isCloseStatusUpdate_Update { if m != nil { return m.Update } return nil } func (x *CloseStatusUpdate) GetClosePending() *PendingUpdate { if x, ok := x.GetUpdate().(*CloseStatusUpdate_ClosePending); ok { return x.ClosePending } return nil } func (x *CloseStatusUpdate) GetChanClose() *ChannelCloseUpdate { if x, ok := x.GetUpdate().(*CloseStatusUpdate_ChanClose); ok { return x.ChanClose } return nil } type isCloseStatusUpdate_Update interface { isCloseStatusUpdate_Update() } type CloseStatusUpdate_ClosePending struct { ClosePending *PendingUpdate `protobuf:"bytes,1,opt,name=close_pending,json=closePending,proto3,oneof"` } type CloseStatusUpdate_ChanClose struct { ChanClose *ChannelCloseUpdate `protobuf:"bytes,3,opt,name=chan_close,json=chanClose,proto3,oneof"` } func (*CloseStatusUpdate_ClosePending) isCloseStatusUpdate_Update() {} func (*CloseStatusUpdate_ChanClose) isCloseStatusUpdate_Update() {} type PendingUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Txid []byte `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` OutputIndex uint32 `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` } func (x *PendingUpdate) Reset() { *x = PendingUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingUpdate) ProtoMessage() {} func (x *PendingUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingUpdate.ProtoReflect.Descriptor instead. func (*PendingUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{60} } func (x *PendingUpdate) GetTxid() []byte { if x != nil { return x.Txid } return nil } func (x *PendingUpdate) GetOutputIndex() uint32 { if x != nil { return x.OutputIndex } return 0 } type ReadyForPsbtFunding struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The P2WSH address of the channel funding multisig address that the below //specified amount in satoshis needs to be sent to. FundingAddress string `protobuf:"bytes,1,opt,name=funding_address,json=fundingAddress,proto3" json:"funding_address,omitempty"` // //The exact amount in satoshis that needs to be sent to the above address to //fund the pending channel. FundingAmount int64 `protobuf:"varint,2,opt,name=funding_amount,json=fundingAmount,proto3" json:"funding_amount,omitempty"` // //A raw PSBT that contains the pending channel output. If a base PSBT was //provided in the PsbtShim, this is the base PSBT with one additional output. //If no base PSBT was specified, this is an otherwise empty PSBT with exactly //one output. Psbt []byte `protobuf:"bytes,3,opt,name=psbt,proto3" json:"psbt,omitempty"` } func (x *ReadyForPsbtFunding) Reset() { *x = ReadyForPsbtFunding{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ReadyForPsbtFunding) String() string { return protoimpl.X.MessageStringOf(x) } func (*ReadyForPsbtFunding) ProtoMessage() {} func (x *ReadyForPsbtFunding) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ReadyForPsbtFunding.ProtoReflect.Descriptor instead. func (*ReadyForPsbtFunding) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{61} } func (x *ReadyForPsbtFunding) GetFundingAddress() string { if x != nil { return x.FundingAddress } return "" } func (x *ReadyForPsbtFunding) GetFundingAmount() int64 { if x != nil { return x.FundingAmount } return 0 } func (x *ReadyForPsbtFunding) GetPsbt() []byte { if x != nil { return x.Psbt } return nil } type BatchOpenChannelRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of channels to open. Channels []*BatchOpenChannel `protobuf:"bytes,1,rep,name=channels,proto3" json:"channels,omitempty"` // The target number of blocks that the funding transaction should be // confirmed by. TargetConf int32 `protobuf:"varint,2,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // A manual fee rate set in sat/vByte that should be used when crafting the // funding transaction. SatPerVbyte int64 `protobuf:"varint,3,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` // The minimum number of confirmations each one of your outputs used for // the funding transaction must satisfy. MinConfs int32 `protobuf:"varint,4,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // Whether unconfirmed outputs should be used as inputs for the funding // transaction. SpendUnconfirmed bool `protobuf:"varint,5,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` // An optional label for the batch transaction, limited to 500 characters. Label string `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"` } func (x *BatchOpenChannelRequest) Reset() { *x = BatchOpenChannelRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *BatchOpenChannelRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*BatchOpenChannelRequest) ProtoMessage() {} func (x *BatchOpenChannelRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use BatchOpenChannelRequest.ProtoReflect.Descriptor instead. func (*BatchOpenChannelRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{62} } func (x *BatchOpenChannelRequest) GetChannels() []*BatchOpenChannel { if x != nil { return x.Channels } return nil } func (x *BatchOpenChannelRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } func (x *BatchOpenChannelRequest) GetSatPerVbyte() int64 { if x != nil { return x.SatPerVbyte } return 0 } func (x *BatchOpenChannelRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *BatchOpenChannelRequest) GetSpendUnconfirmed() bool { if x != nil { return x.SpendUnconfirmed } return false } func (x *BatchOpenChannelRequest) GetLabel() string { if x != nil { return x.Label } return "" } type BatchOpenChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pubkey of the node to open a channel with. When using REST, this // field must be encoded as base64. NodePubkey []byte `protobuf:"bytes,1,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"` // The number of satoshis the wallet should commit to the channel. LocalFundingAmount int64 `protobuf:"varint,2,opt,name=local_funding_amount,json=localFundingAmount,proto3" json:"local_funding_amount,omitempty"` // The number of satoshis to push to the remote side as part of the initial // commitment state. PushSat int64 `protobuf:"varint,3,opt,name=push_sat,json=pushSat,proto3" json:"push_sat,omitempty"` // Whether this channel should be private, not announced to the greater // network. Private bool `protobuf:"varint,4,opt,name=private,proto3" json:"private,omitempty"` // The minimum value in millisatoshi we will require for incoming HTLCs on // the channel. MinHtlcMsat int64 `protobuf:"varint,5,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` // The delay we require on the remote's commitment transaction. If this is // not set, it will be scaled automatically with the channel size. RemoteCsvDelay uint32 `protobuf:"varint,6,opt,name=remote_csv_delay,json=remoteCsvDelay,proto3" json:"remote_csv_delay,omitempty"` // //Close address is an optional address which specifies the address to which //funds should be paid out to upon cooperative close. This field may only be //set if the peer supports the option upfront feature bit (call listpeers //to check). The remote peer will only accept cooperative closes to this //address if it is set. // //Note: If this value is set on channel creation, you will *not* be able to //cooperatively close out to a different address. CloseAddress string `protobuf:"bytes,7,opt,name=close_address,json=closeAddress,proto3" json:"close_address,omitempty"` // //An optional, unique identifier of 32 random bytes that will be used as the //pending channel ID to identify the channel while it is in the pre-pending //state. PendingChanId []byte `protobuf:"bytes,8,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //The explicit commitment type to use. Note this field will only be used if //the remote peer supports explicit channel negotiation. CommitmentType CommitmentType `protobuf:"varint,9,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` } func (x *BatchOpenChannel) Reset() { *x = BatchOpenChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *BatchOpenChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*BatchOpenChannel) ProtoMessage() {} func (x *BatchOpenChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use BatchOpenChannel.ProtoReflect.Descriptor instead. func (*BatchOpenChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{63} } func (x *BatchOpenChannel) GetNodePubkey() []byte { if x != nil { return x.NodePubkey } return nil } func (x *BatchOpenChannel) GetLocalFundingAmount() int64 { if x != nil { return x.LocalFundingAmount } return 0 } func (x *BatchOpenChannel) GetPushSat() int64 { if x != nil { return x.PushSat } return 0 } func (x *BatchOpenChannel) GetPrivate() bool { if x != nil { return x.Private } return false } func (x *BatchOpenChannel) GetMinHtlcMsat() int64 { if x != nil { return x.MinHtlcMsat } return 0 } func (x *BatchOpenChannel) GetRemoteCsvDelay() uint32 { if x != nil { return x.RemoteCsvDelay } return 0 } func (x *BatchOpenChannel) GetCloseAddress() string { if x != nil { return x.CloseAddress } return "" } func (x *BatchOpenChannel) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *BatchOpenChannel) GetCommitmentType() CommitmentType { if x != nil { return x.CommitmentType } return CommitmentType_UNKNOWN_COMMITMENT_TYPE } type BatchOpenChannelResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields PendingChannels []*PendingUpdate `protobuf:"bytes,1,rep,name=pending_channels,json=pendingChannels,proto3" json:"pending_channels,omitempty"` } func (x *BatchOpenChannelResponse) Reset() { *x = BatchOpenChannelResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *BatchOpenChannelResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*BatchOpenChannelResponse) ProtoMessage() {} func (x *BatchOpenChannelResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use BatchOpenChannelResponse.ProtoReflect.Descriptor instead. func (*BatchOpenChannelResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{64} } func (x *BatchOpenChannelResponse) GetPendingChannels() []*PendingUpdate { if x != nil { return x.PendingChannels } return nil } type OpenChannelRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // A manual fee rate set in sat/vbyte that should be used when crafting the // funding transaction. SatPerVbyte uint64 `protobuf:"varint,1,opt,name=sat_per_vbyte,json=satPerVbyte,proto3" json:"sat_per_vbyte,omitempty"` // //The pubkey of the node to open a channel with. When using REST, this field //must be encoded as base64. NodePubkey []byte `protobuf:"bytes,2,opt,name=node_pubkey,json=nodePubkey,proto3" json:"node_pubkey,omitempty"` // //The hex encoded pubkey of the node to open a channel with. Deprecated now //that the REST gateway supports base64 encoding of bytes fields. // // Deprecated: Do not use. NodePubkeyString string `protobuf:"bytes,3,opt,name=node_pubkey_string,json=nodePubkeyString,proto3" json:"node_pubkey_string,omitempty"` // The number of satoshis the wallet should commit to the channel LocalFundingAmount int64 `protobuf:"varint,4,opt,name=local_funding_amount,json=localFundingAmount,proto3" json:"local_funding_amount,omitempty"` // The number of satoshis to push to the remote side as part of the initial // commitment state PushSat int64 `protobuf:"varint,5,opt,name=push_sat,json=pushSat,proto3" json:"push_sat,omitempty"` // The target number of blocks that the funding transaction should be // confirmed by. TargetConf int32 `protobuf:"varint,6,opt,name=target_conf,json=targetConf,proto3" json:"target_conf,omitempty"` // Deprecated, use sat_per_vbyte. // A manual fee rate set in sat/vbyte that should be used when crafting the // funding transaction. // // Deprecated: Do not use. SatPerByte int64 `protobuf:"varint,7,opt,name=sat_per_byte,json=satPerByte,proto3" json:"sat_per_byte,omitempty"` // Whether this channel should be private, not announced to the greater // network. Private bool `protobuf:"varint,8,opt,name=private,proto3" json:"private,omitempty"` // The minimum value in millisatoshi we will require for incoming HTLCs on // the channel. MinHtlcMsat int64 `protobuf:"varint,9,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` // The delay we require on the remote's commitment transaction. If this is // not set, it will be scaled automatically with the channel size. RemoteCsvDelay uint32 `protobuf:"varint,10,opt,name=remote_csv_delay,json=remoteCsvDelay,proto3" json:"remote_csv_delay,omitempty"` // The minimum number of confirmations each one of your outputs used for // the funding transaction must satisfy. MinConfs int32 `protobuf:"varint,11,opt,name=min_confs,json=minConfs,proto3" json:"min_confs,omitempty"` // Whether unconfirmed outputs should be used as inputs for the funding // transaction. SpendUnconfirmed bool `protobuf:"varint,12,opt,name=spend_unconfirmed,json=spendUnconfirmed,proto3" json:"spend_unconfirmed,omitempty"` // //Close address is an optional address which specifies the address to which //funds should be paid out to upon cooperative close. This field may only be //set if the peer supports the option upfront feature bit (call listpeers //to check). The remote peer will only accept cooperative closes to this //address if it is set. // //Note: If this value is set on channel creation, you will *not* be able to //cooperatively close out to a different address. CloseAddress string `protobuf:"bytes,13,opt,name=close_address,json=closeAddress,proto3" json:"close_address,omitempty"` // //Funding shims are an optional argument that allow the caller to intercept //certain funding functionality. For example, a shim can be provided to use a //particular key for the commitment key (ideally cold) rather than use one //that is generated by the wallet as normal, or signal that signing will be //carried out in an interactive manner (PSBT based). FundingShim *FundingShim `protobuf:"bytes,14,opt,name=funding_shim,json=fundingShim,proto3" json:"funding_shim,omitempty"` // //The maximum amount of coins in millisatoshi that can be pending within //the channel. It only applies to the remote party. RemoteMaxValueInFlightMsat uint64 `protobuf:"varint,15,opt,name=remote_max_value_in_flight_msat,json=remoteMaxValueInFlightMsat,proto3" json:"remote_max_value_in_flight_msat,omitempty"` // //The maximum number of concurrent HTLCs we will allow the remote party to add //to the commitment transaction. RemoteMaxHtlcs uint32 `protobuf:"varint,16,opt,name=remote_max_htlcs,json=remoteMaxHtlcs,proto3" json:"remote_max_htlcs,omitempty"` // //Max local csv is the maximum csv delay we will allow for our own commitment //transaction. MaxLocalCsv uint32 `protobuf:"varint,17,opt,name=max_local_csv,json=maxLocalCsv,proto3" json:"max_local_csv,omitempty"` // //The explicit commitment type to use. Note this field will only be used if //the remote peer supports explicit channel negotiation. CommitmentType CommitmentType `protobuf:"varint,18,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` } func (x *OpenChannelRequest) Reset() { *x = OpenChannelRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *OpenChannelRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*OpenChannelRequest) ProtoMessage() {} func (x *OpenChannelRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use OpenChannelRequest.ProtoReflect.Descriptor instead. func (*OpenChannelRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{65} } func (x *OpenChannelRequest) GetSatPerVbyte() uint64 { if x != nil { return x.SatPerVbyte } return 0 } func (x *OpenChannelRequest) GetNodePubkey() []byte { if x != nil { return x.NodePubkey } return nil } // Deprecated: Do not use. func (x *OpenChannelRequest) GetNodePubkeyString() string { if x != nil { return x.NodePubkeyString } return "" } func (x *OpenChannelRequest) GetLocalFundingAmount() int64 { if x != nil { return x.LocalFundingAmount } return 0 } func (x *OpenChannelRequest) GetPushSat() int64 { if x != nil { return x.PushSat } return 0 } func (x *OpenChannelRequest) GetTargetConf() int32 { if x != nil { return x.TargetConf } return 0 } // Deprecated: Do not use. func (x *OpenChannelRequest) GetSatPerByte() int64 { if x != nil { return x.SatPerByte } return 0 } func (x *OpenChannelRequest) GetPrivate() bool { if x != nil { return x.Private } return false } func (x *OpenChannelRequest) GetMinHtlcMsat() int64 { if x != nil { return x.MinHtlcMsat } return 0 } func (x *OpenChannelRequest) GetRemoteCsvDelay() uint32 { if x != nil { return x.RemoteCsvDelay } return 0 } func (x *OpenChannelRequest) GetMinConfs() int32 { if x != nil { return x.MinConfs } return 0 } func (x *OpenChannelRequest) GetSpendUnconfirmed() bool { if x != nil { return x.SpendUnconfirmed } return false } func (x *OpenChannelRequest) GetCloseAddress() string { if x != nil { return x.CloseAddress } return "" } func (x *OpenChannelRequest) GetFundingShim() *FundingShim { if x != nil { return x.FundingShim } return nil } func (x *OpenChannelRequest) GetRemoteMaxValueInFlightMsat() uint64 { if x != nil { return x.RemoteMaxValueInFlightMsat } return 0 } func (x *OpenChannelRequest) GetRemoteMaxHtlcs() uint32 { if x != nil { return x.RemoteMaxHtlcs } return 0 } func (x *OpenChannelRequest) GetMaxLocalCsv() uint32 { if x != nil { return x.MaxLocalCsv } return 0 } func (x *OpenChannelRequest) GetCommitmentType() CommitmentType { if x != nil { return x.CommitmentType } return CommitmentType_UNKNOWN_COMMITMENT_TYPE } type OpenStatusUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Update: // *OpenStatusUpdate_ChanPending // *OpenStatusUpdate_ChanOpen // *OpenStatusUpdate_PsbtFund Update isOpenStatusUpdate_Update `protobuf_oneof:"update"` // //The pending channel ID of the created channel. This value may be used to //further the funding flow manually via the FundingStateStep method. PendingChanId []byte `protobuf:"bytes,4,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` } func (x *OpenStatusUpdate) Reset() { *x = OpenStatusUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *OpenStatusUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*OpenStatusUpdate) ProtoMessage() {} func (x *OpenStatusUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use OpenStatusUpdate.ProtoReflect.Descriptor instead. func (*OpenStatusUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{66} } func (m *OpenStatusUpdate) GetUpdate() isOpenStatusUpdate_Update { if m != nil { return m.Update } return nil } func (x *OpenStatusUpdate) GetChanPending() *PendingUpdate { if x, ok := x.GetUpdate().(*OpenStatusUpdate_ChanPending); ok { return x.ChanPending } return nil } func (x *OpenStatusUpdate) GetChanOpen() *ChannelOpenUpdate { if x, ok := x.GetUpdate().(*OpenStatusUpdate_ChanOpen); ok { return x.ChanOpen } return nil } func (x *OpenStatusUpdate) GetPsbtFund() *ReadyForPsbtFunding { if x, ok := x.GetUpdate().(*OpenStatusUpdate_PsbtFund); ok { return x.PsbtFund } return nil } func (x *OpenStatusUpdate) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } type isOpenStatusUpdate_Update interface { isOpenStatusUpdate_Update() } type OpenStatusUpdate_ChanPending struct { // //Signals that the channel is now fully negotiated and the funding //transaction published. ChanPending *PendingUpdate `protobuf:"bytes,1,opt,name=chan_pending,json=chanPending,proto3,oneof"` } type OpenStatusUpdate_ChanOpen struct { // //Signals that the channel's funding transaction has now reached the //required number of confirmations on chain and can be used. ChanOpen *ChannelOpenUpdate `protobuf:"bytes,3,opt,name=chan_open,json=chanOpen,proto3,oneof"` } type OpenStatusUpdate_PsbtFund struct { // //Signals that the funding process has been suspended and the construction //of a PSBT that funds the channel PK script is now required. PsbtFund *ReadyForPsbtFunding `protobuf:"bytes,5,opt,name=psbt_fund,json=psbtFund,proto3,oneof"` } func (*OpenStatusUpdate_ChanPending) isOpenStatusUpdate_Update() {} func (*OpenStatusUpdate_ChanOpen) isOpenStatusUpdate_Update() {} func (*OpenStatusUpdate_PsbtFund) isOpenStatusUpdate_Update() {} type KeyLocator struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The family of key being identified. KeyFamily int32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` // The precise index of the key being identified. KeyIndex int32 `protobuf:"varint,2,opt,name=key_index,json=keyIndex,proto3" json:"key_index,omitempty"` } func (x *KeyLocator) Reset() { *x = KeyLocator{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *KeyLocator) String() string { return protoimpl.X.MessageStringOf(x) } func (*KeyLocator) ProtoMessage() {} func (x *KeyLocator) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use KeyLocator.ProtoReflect.Descriptor instead. func (*KeyLocator) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{67} } func (x *KeyLocator) GetKeyFamily() int32 { if x != nil { return x.KeyFamily } return 0 } func (x *KeyLocator) GetKeyIndex() int32 { if x != nil { return x.KeyIndex } return 0 } type KeyDescriptor struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The raw bytes of the key being identified. RawKeyBytes []byte `protobuf:"bytes,1,opt,name=raw_key_bytes,json=rawKeyBytes,proto3" json:"raw_key_bytes,omitempty"` // //The key locator that identifies which key to use for signing. KeyLoc *KeyLocator `protobuf:"bytes,2,opt,name=key_loc,json=keyLoc,proto3" json:"key_loc,omitempty"` } func (x *KeyDescriptor) Reset() { *x = KeyDescriptor{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *KeyDescriptor) String() string { return protoimpl.X.MessageStringOf(x) } func (*KeyDescriptor) ProtoMessage() {} func (x *KeyDescriptor) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use KeyDescriptor.ProtoReflect.Descriptor instead. func (*KeyDescriptor) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{68} } func (x *KeyDescriptor) GetRawKeyBytes() []byte { if x != nil { return x.RawKeyBytes } return nil } func (x *KeyDescriptor) GetKeyLoc() *KeyLocator { if x != nil { return x.KeyLoc } return nil } type ChanPointShim struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The size of the pre-crafted output to be used as the channel point for this //channel funding. Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"` // The target channel point to refrence in created commitment transactions. ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` // Our local key to use when creating the multi-sig output. LocalKey *KeyDescriptor `protobuf:"bytes,3,opt,name=local_key,json=localKey,proto3" json:"local_key,omitempty"` // The key of the remote party to use when creating the multi-sig output. RemoteKey []byte `protobuf:"bytes,4,opt,name=remote_key,json=remoteKey,proto3" json:"remote_key,omitempty"` // //If non-zero, then this will be used as the pending channel ID on the wire //protocol to initate the funding request. This is an optional field, and //should only be set if the responder is already expecting a specific pending //channel ID. PendingChanId []byte `protobuf:"bytes,5,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //This uint32 indicates if this channel is to be considered 'frozen'. A frozen //channel does not allow a cooperative channel close by the initiator. The //thaw_height is the height that this restriction stops applying to the //channel. The height can be interpreted in two ways: as a relative height if //the value is less than 500,000, or as an absolute height otherwise. ThawHeight uint32 `protobuf:"varint,6,opt,name=thaw_height,json=thawHeight,proto3" json:"thaw_height,omitempty"` } func (x *ChanPointShim) Reset() { *x = ChanPointShim{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChanPointShim) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChanPointShim) ProtoMessage() {} func (x *ChanPointShim) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChanPointShim.ProtoReflect.Descriptor instead. func (*ChanPointShim) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{69} } func (x *ChanPointShim) GetAmt() int64 { if x != nil { return x.Amt } return 0 } func (x *ChanPointShim) GetChanPoint() *ChannelPoint { if x != nil { return x.ChanPoint } return nil } func (x *ChanPointShim) GetLocalKey() *KeyDescriptor { if x != nil { return x.LocalKey } return nil } func (x *ChanPointShim) GetRemoteKey() []byte { if x != nil { return x.RemoteKey } return nil } func (x *ChanPointShim) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *ChanPointShim) GetThawHeight() uint32 { if x != nil { return x.ThawHeight } return 0 } type PsbtShim struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A unique identifier of 32 random bytes that will be used as the pending //channel ID to identify the PSBT state machine when interacting with it and //on the wire protocol to initiate the funding request. PendingChanId []byte `protobuf:"bytes,1,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //An optional base PSBT the new channel output will be added to. If this is //non-empty, it must be a binary serialized PSBT. BasePsbt []byte `protobuf:"bytes,2,opt,name=base_psbt,json=basePsbt,proto3" json:"base_psbt,omitempty"` // //If a channel should be part of a batch (multiple channel openings in one //transaction), it can be dangerous if the whole batch transaction is //published too early before all channel opening negotiations are completed. //This flag prevents this particular channel from broadcasting the transaction //after the negotiation with the remote peer. In a batch of channel openings //this flag should be set to true for every channel but the very last. NoPublish bool `protobuf:"varint,3,opt,name=no_publish,json=noPublish,proto3" json:"no_publish,omitempty"` } func (x *PsbtShim) Reset() { *x = PsbtShim{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PsbtShim) String() string { return protoimpl.X.MessageStringOf(x) } func (*PsbtShim) ProtoMessage() {} func (x *PsbtShim) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PsbtShim.ProtoReflect.Descriptor instead. func (*PsbtShim) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{70} } func (x *PsbtShim) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *PsbtShim) GetBasePsbt() []byte { if x != nil { return x.BasePsbt } return nil } func (x *PsbtShim) GetNoPublish() bool { if x != nil { return x.NoPublish } return false } type FundingShim struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Shim: // *FundingShim_ChanPointShim // *FundingShim_PsbtShim Shim isFundingShim_Shim `protobuf_oneof:"shim"` } func (x *FundingShim) Reset() { *x = FundingShim{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingShim) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingShim) ProtoMessage() {} func (x *FundingShim) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingShim.ProtoReflect.Descriptor instead. func (*FundingShim) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{71} } func (m *FundingShim) GetShim() isFundingShim_Shim { if m != nil { return m.Shim } return nil } func (x *FundingShim) GetChanPointShim() *ChanPointShim { if x, ok := x.GetShim().(*FundingShim_ChanPointShim); ok { return x.ChanPointShim } return nil } func (x *FundingShim) GetPsbtShim() *PsbtShim { if x, ok := x.GetShim().(*FundingShim_PsbtShim); ok { return x.PsbtShim } return nil } type isFundingShim_Shim interface { isFundingShim_Shim() } type FundingShim_ChanPointShim struct { // //A channel shim where the channel point was fully constructed outside //of lnd's wallet and the transaction might already be published. ChanPointShim *ChanPointShim `protobuf:"bytes,1,opt,name=chan_point_shim,json=chanPointShim,proto3,oneof"` } type FundingShim_PsbtShim struct { // //A channel shim that uses a PSBT to fund and sign the channel funding //transaction. PsbtShim *PsbtShim `protobuf:"bytes,2,opt,name=psbt_shim,json=psbtShim,proto3,oneof"` } func (*FundingShim_ChanPointShim) isFundingShim_Shim() {} func (*FundingShim_PsbtShim) isFundingShim_Shim() {} type FundingShimCancel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pending channel ID of the channel to cancel the funding shim for. PendingChanId []byte `protobuf:"bytes,1,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` } func (x *FundingShimCancel) Reset() { *x = FundingShimCancel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingShimCancel) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingShimCancel) ProtoMessage() {} func (x *FundingShimCancel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingShimCancel.ProtoReflect.Descriptor instead. func (*FundingShimCancel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{72} } func (x *FundingShimCancel) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } type FundingPsbtVerify struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The funded but not yet signed PSBT that sends the exact channel capacity //amount to the PK script returned in the open channel message in a previous //step. FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"` // The pending channel ID of the channel to get the PSBT for. PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //Can only be used if the no_publish flag was set to true in the OpenChannel //call meaning that the caller is solely responsible for publishing the final //funding transaction. If skip_finalize is set to true then lnd will not wait //for a FundingPsbtFinalize state step and instead assumes that a transaction //with the same TXID as the passed in PSBT will eventually confirm. //IT IS ABSOLUTELY IMPERATIVE that the TXID of the transaction that is //eventually published does have the _same TXID_ as the verified PSBT. That //means no inputs or outputs can change, only signatures can be added. If the //TXID changes between this call and the publish step then the channel will //never be created and the funds will be in limbo. SkipFinalize bool `protobuf:"varint,3,opt,name=skip_finalize,json=skipFinalize,proto3" json:"skip_finalize,omitempty"` } func (x *FundingPsbtVerify) Reset() { *x = FundingPsbtVerify{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingPsbtVerify) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingPsbtVerify) ProtoMessage() {} func (x *FundingPsbtVerify) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingPsbtVerify.ProtoReflect.Descriptor instead. func (*FundingPsbtVerify) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{73} } func (x *FundingPsbtVerify) GetFundedPsbt() []byte { if x != nil { return x.FundedPsbt } return nil } func (x *FundingPsbtVerify) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *FundingPsbtVerify) GetSkipFinalize() bool { if x != nil { return x.SkipFinalize } return false } type FundingPsbtFinalize struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The funded PSBT that contains all witness data to send the exact channel //capacity amount to the PK script returned in the open channel message in a //previous step. Cannot be set at the same time as final_raw_tx. SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"` // The pending channel ID of the channel to get the PSBT for. PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` // //As an alternative to the signed PSBT with all witness data, the final raw //wire format transaction can also be specified directly. Cannot be set at the //same time as signed_psbt. FinalRawTx []byte `protobuf:"bytes,3,opt,name=final_raw_tx,json=finalRawTx,proto3" json:"final_raw_tx,omitempty"` } func (x *FundingPsbtFinalize) Reset() { *x = FundingPsbtFinalize{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingPsbtFinalize) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingPsbtFinalize) ProtoMessage() {} func (x *FundingPsbtFinalize) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingPsbtFinalize.ProtoReflect.Descriptor instead. func (*FundingPsbtFinalize) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{74} } func (x *FundingPsbtFinalize) GetSignedPsbt() []byte { if x != nil { return x.SignedPsbt } return nil } func (x *FundingPsbtFinalize) GetPendingChanId() []byte { if x != nil { return x.PendingChanId } return nil } func (x *FundingPsbtFinalize) GetFinalRawTx() []byte { if x != nil { return x.FinalRawTx } return nil } type FundingTransitionMsg struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Trigger: // *FundingTransitionMsg_ShimRegister // *FundingTransitionMsg_ShimCancel // *FundingTransitionMsg_PsbtVerify // *FundingTransitionMsg_PsbtFinalize Trigger isFundingTransitionMsg_Trigger `protobuf_oneof:"trigger"` } func (x *FundingTransitionMsg) Reset() { *x = FundingTransitionMsg{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingTransitionMsg) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingTransitionMsg) ProtoMessage() {} func (x *FundingTransitionMsg) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingTransitionMsg.ProtoReflect.Descriptor instead. func (*FundingTransitionMsg) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{75} } func (m *FundingTransitionMsg) GetTrigger() isFundingTransitionMsg_Trigger { if m != nil { return m.Trigger } return nil } func (x *FundingTransitionMsg) GetShimRegister() *FundingShim { if x, ok := x.GetTrigger().(*FundingTransitionMsg_ShimRegister); ok { return x.ShimRegister } return nil } func (x *FundingTransitionMsg) GetShimCancel() *FundingShimCancel { if x, ok := x.GetTrigger().(*FundingTransitionMsg_ShimCancel); ok { return x.ShimCancel } return nil } func (x *FundingTransitionMsg) GetPsbtVerify() *FundingPsbtVerify { if x, ok := x.GetTrigger().(*FundingTransitionMsg_PsbtVerify); ok { return x.PsbtVerify } return nil } func (x *FundingTransitionMsg) GetPsbtFinalize() *FundingPsbtFinalize { if x, ok := x.GetTrigger().(*FundingTransitionMsg_PsbtFinalize); ok { return x.PsbtFinalize } return nil } type isFundingTransitionMsg_Trigger interface { isFundingTransitionMsg_Trigger() } type FundingTransitionMsg_ShimRegister struct { // //The funding shim to register. This should be used before any //channel funding has began by the remote party, as it is intended as a //preparatory step for the full channel funding. ShimRegister *FundingShim `protobuf:"bytes,1,opt,name=shim_register,json=shimRegister,proto3,oneof"` } type FundingTransitionMsg_ShimCancel struct { // Used to cancel an existing registered funding shim. ShimCancel *FundingShimCancel `protobuf:"bytes,2,opt,name=shim_cancel,json=shimCancel,proto3,oneof"` } type FundingTransitionMsg_PsbtVerify struct { // //Used to continue a funding flow that was initiated to be executed //through a PSBT. This step verifies that the PSBT contains the correct //outputs to fund the channel. PsbtVerify *FundingPsbtVerify `protobuf:"bytes,3,opt,name=psbt_verify,json=psbtVerify,proto3,oneof"` } type FundingTransitionMsg_PsbtFinalize struct { // //Used to continue a funding flow that was initiated to be executed //through a PSBT. This step finalizes the funded and signed PSBT, finishes //negotiation with the peer and finally publishes the resulting funding //transaction. PsbtFinalize *FundingPsbtFinalize `protobuf:"bytes,4,opt,name=psbt_finalize,json=psbtFinalize,proto3,oneof"` } func (*FundingTransitionMsg_ShimRegister) isFundingTransitionMsg_Trigger() {} func (*FundingTransitionMsg_ShimCancel) isFundingTransitionMsg_Trigger() {} func (*FundingTransitionMsg_PsbtVerify) isFundingTransitionMsg_Trigger() {} func (*FundingTransitionMsg_PsbtFinalize) isFundingTransitionMsg_Trigger() {} type FundingStateStepResp struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *FundingStateStepResp) Reset() { *x = FundingStateStepResp{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FundingStateStepResp) String() string { return protoimpl.X.MessageStringOf(x) } func (*FundingStateStepResp) ProtoMessage() {} func (x *FundingStateStepResp) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FundingStateStepResp.ProtoReflect.Descriptor instead. func (*FundingStateStepResp) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{76} } type PendingHTLC struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The direction within the channel that the htlc was sent Incoming bool `protobuf:"varint,1,opt,name=incoming,proto3" json:"incoming,omitempty"` // The total value of the htlc Amount int64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"` // The final output to be swept back to the user's wallet Outpoint string `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // The next block height at which we can spend the current stage MaturityHeight uint32 `protobuf:"varint,4,opt,name=maturity_height,json=maturityHeight,proto3" json:"maturity_height,omitempty"` // //The number of blocks remaining until the current stage can be swept. //Negative values indicate how many blocks have passed since becoming //mature. BlocksTilMaturity int32 `protobuf:"varint,5,opt,name=blocks_til_maturity,json=blocksTilMaturity,proto3" json:"blocks_til_maturity,omitempty"` // Indicates whether the htlc is in its first or second stage of recovery Stage uint32 `protobuf:"varint,6,opt,name=stage,proto3" json:"stage,omitempty"` } func (x *PendingHTLC) Reset() { *x = PendingHTLC{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingHTLC) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingHTLC) ProtoMessage() {} func (x *PendingHTLC) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingHTLC.ProtoReflect.Descriptor instead. func (*PendingHTLC) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{77} } func (x *PendingHTLC) GetIncoming() bool { if x != nil { return x.Incoming } return false } func (x *PendingHTLC) GetAmount() int64 { if x != nil { return x.Amount } return 0 } func (x *PendingHTLC) GetOutpoint() string { if x != nil { return x.Outpoint } return "" } func (x *PendingHTLC) GetMaturityHeight() uint32 { if x != nil { return x.MaturityHeight } return 0 } func (x *PendingHTLC) GetBlocksTilMaturity() int32 { if x != nil { return x.BlocksTilMaturity } return 0 } func (x *PendingHTLC) GetStage() uint32 { if x != nil { return x.Stage } return 0 } type PendingChannelsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *PendingChannelsRequest) Reset() { *x = PendingChannelsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsRequest) ProtoMessage() {} func (x *PendingChannelsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsRequest.ProtoReflect.Descriptor instead. func (*PendingChannelsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{78} } type PendingChannelsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The balance in satoshis encumbered in pending channels TotalLimboBalance int64 `protobuf:"varint,1,opt,name=total_limbo_balance,json=totalLimboBalance,proto3" json:"total_limbo_balance,omitempty"` // Channels pending opening PendingOpenChannels []*PendingChannelsResponse_PendingOpenChannel `protobuf:"bytes,2,rep,name=pending_open_channels,json=pendingOpenChannels,proto3" json:"pending_open_channels,omitempty"` // //Deprecated: Channels pending closing previously contained cooperatively //closed channels with a single confirmation. These channels are now //considered closed from the time we see them on chain. // // Deprecated: Do not use. PendingClosingChannels []*PendingChannelsResponse_ClosedChannel `protobuf:"bytes,3,rep,name=pending_closing_channels,json=pendingClosingChannels,proto3" json:"pending_closing_channels,omitempty"` // Channels pending force closing PendingForceClosingChannels []*PendingChannelsResponse_ForceClosedChannel `protobuf:"bytes,4,rep,name=pending_force_closing_channels,json=pendingForceClosingChannels,proto3" json:"pending_force_closing_channels,omitempty"` // Channels waiting for closing tx to confirm WaitingCloseChannels []*PendingChannelsResponse_WaitingCloseChannel `protobuf:"bytes,5,rep,name=waiting_close_channels,json=waitingCloseChannels,proto3" json:"waiting_close_channels,omitempty"` } func (x *PendingChannelsResponse) Reset() { *x = PendingChannelsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse) ProtoMessage() {} func (x *PendingChannelsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79} } func (x *PendingChannelsResponse) GetTotalLimboBalance() int64 { if x != nil { return x.TotalLimboBalance } return 0 } func (x *PendingChannelsResponse) GetPendingOpenChannels() []*PendingChannelsResponse_PendingOpenChannel { if x != nil { return x.PendingOpenChannels } return nil } // Deprecated: Do not use. func (x *PendingChannelsResponse) GetPendingClosingChannels() []*PendingChannelsResponse_ClosedChannel { if x != nil { return x.PendingClosingChannels } return nil } func (x *PendingChannelsResponse) GetPendingForceClosingChannels() []*PendingChannelsResponse_ForceClosedChannel { if x != nil { return x.PendingForceClosingChannels } return nil } func (x *PendingChannelsResponse) GetWaitingCloseChannels() []*PendingChannelsResponse_WaitingCloseChannel { if x != nil { return x.WaitingCloseChannels } return nil } type ChannelEventSubscription struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ChannelEventSubscription) Reset() { *x = ChannelEventSubscription{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelEventSubscription) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelEventSubscription) ProtoMessage() {} func (x *ChannelEventSubscription) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelEventSubscription.ProtoReflect.Descriptor instead. func (*ChannelEventSubscription) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{80} } type ChannelEventUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Channel: // *ChannelEventUpdate_OpenChannel // *ChannelEventUpdate_ClosedChannel // *ChannelEventUpdate_ActiveChannel // *ChannelEventUpdate_InactiveChannel // *ChannelEventUpdate_PendingOpenChannel // *ChannelEventUpdate_FullyResolvedChannel Channel isChannelEventUpdate_Channel `protobuf_oneof:"channel"` Type ChannelEventUpdate_UpdateType `protobuf:"varint,5,opt,name=type,proto3,enum=lnrpc.ChannelEventUpdate_UpdateType" json:"type,omitempty"` } func (x *ChannelEventUpdate) Reset() { *x = ChannelEventUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelEventUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelEventUpdate) ProtoMessage() {} func (x *ChannelEventUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelEventUpdate.ProtoReflect.Descriptor instead. func (*ChannelEventUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{81} } func (m *ChannelEventUpdate) GetChannel() isChannelEventUpdate_Channel { if m != nil { return m.Channel } return nil } func (x *ChannelEventUpdate) GetOpenChannel() *Channel { if x, ok := x.GetChannel().(*ChannelEventUpdate_OpenChannel); ok { return x.OpenChannel } return nil } func (x *ChannelEventUpdate) GetClosedChannel() *ChannelCloseSummary { if x, ok := x.GetChannel().(*ChannelEventUpdate_ClosedChannel); ok { return x.ClosedChannel } return nil } func (x *ChannelEventUpdate) GetActiveChannel() *ChannelPoint { if x, ok := x.GetChannel().(*ChannelEventUpdate_ActiveChannel); ok { return x.ActiveChannel } return nil } func (x *ChannelEventUpdate) GetInactiveChannel() *ChannelPoint { if x, ok := x.GetChannel().(*ChannelEventUpdate_InactiveChannel); ok { return x.InactiveChannel } return nil } func (x *ChannelEventUpdate) GetPendingOpenChannel() *PendingUpdate { if x, ok := x.GetChannel().(*ChannelEventUpdate_PendingOpenChannel); ok { return x.PendingOpenChannel } return nil } func (x *ChannelEventUpdate) GetFullyResolvedChannel() *ChannelPoint { if x, ok := x.GetChannel().(*ChannelEventUpdate_FullyResolvedChannel); ok { return x.FullyResolvedChannel } return nil } func (x *ChannelEventUpdate) GetType() ChannelEventUpdate_UpdateType { if x != nil { return x.Type } return ChannelEventUpdate_OPEN_CHANNEL } type isChannelEventUpdate_Channel interface { isChannelEventUpdate_Channel() } type ChannelEventUpdate_OpenChannel struct { OpenChannel *Channel `protobuf:"bytes,1,opt,name=open_channel,json=openChannel,proto3,oneof"` } type ChannelEventUpdate_ClosedChannel struct { ClosedChannel *ChannelCloseSummary `protobuf:"bytes,2,opt,name=closed_channel,json=closedChannel,proto3,oneof"` } type ChannelEventUpdate_ActiveChannel struct { ActiveChannel *ChannelPoint `protobuf:"bytes,3,opt,name=active_channel,json=activeChannel,proto3,oneof"` } type ChannelEventUpdate_InactiveChannel struct { InactiveChannel *ChannelPoint `protobuf:"bytes,4,opt,name=inactive_channel,json=inactiveChannel,proto3,oneof"` } type ChannelEventUpdate_PendingOpenChannel struct { PendingOpenChannel *PendingUpdate `protobuf:"bytes,6,opt,name=pending_open_channel,json=pendingOpenChannel,proto3,oneof"` } type ChannelEventUpdate_FullyResolvedChannel struct { FullyResolvedChannel *ChannelPoint `protobuf:"bytes,7,opt,name=fully_resolved_channel,json=fullyResolvedChannel,proto3,oneof"` } func (*ChannelEventUpdate_OpenChannel) isChannelEventUpdate_Channel() {} func (*ChannelEventUpdate_ClosedChannel) isChannelEventUpdate_Channel() {} func (*ChannelEventUpdate_ActiveChannel) isChannelEventUpdate_Channel() {} func (*ChannelEventUpdate_InactiveChannel) isChannelEventUpdate_Channel() {} func (*ChannelEventUpdate_PendingOpenChannel) isChannelEventUpdate_Channel() {} func (*ChannelEventUpdate_FullyResolvedChannel) isChannelEventUpdate_Channel() {} type WalletAccountBalance struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The confirmed balance of the account (with >= 1 confirmations). ConfirmedBalance int64 `protobuf:"varint,1,opt,name=confirmed_balance,json=confirmedBalance,proto3" json:"confirmed_balance,omitempty"` // The unconfirmed balance of the account (with 0 confirmations). UnconfirmedBalance int64 `protobuf:"varint,2,opt,name=unconfirmed_balance,json=unconfirmedBalance,proto3" json:"unconfirmed_balance,omitempty"` } func (x *WalletAccountBalance) Reset() { *x = WalletAccountBalance{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *WalletAccountBalance) String() string { return protoimpl.X.MessageStringOf(x) } func (*WalletAccountBalance) ProtoMessage() {} func (x *WalletAccountBalance) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use WalletAccountBalance.ProtoReflect.Descriptor instead. func (*WalletAccountBalance) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{82} } func (x *WalletAccountBalance) GetConfirmedBalance() int64 { if x != nil { return x.ConfirmedBalance } return 0 } func (x *WalletAccountBalance) GetUnconfirmedBalance() int64 { if x != nil { return x.UnconfirmedBalance } return 0 } type WalletBalanceRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *WalletBalanceRequest) Reset() { *x = WalletBalanceRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *WalletBalanceRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*WalletBalanceRequest) ProtoMessage() {} func (x *WalletBalanceRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use WalletBalanceRequest.ProtoReflect.Descriptor instead. func (*WalletBalanceRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{83} } type WalletBalanceResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The balance of the wallet TotalBalance int64 `protobuf:"varint,1,opt,name=total_balance,json=totalBalance,proto3" json:"total_balance,omitempty"` // The confirmed balance of a wallet(with >= 1 confirmations) ConfirmedBalance int64 `protobuf:"varint,2,opt,name=confirmed_balance,json=confirmedBalance,proto3" json:"confirmed_balance,omitempty"` // The unconfirmed balance of a wallet(with 0 confirmations) UnconfirmedBalance int64 `protobuf:"varint,3,opt,name=unconfirmed_balance,json=unconfirmedBalance,proto3" json:"unconfirmed_balance,omitempty"` // A mapping of each wallet account's name to its balance. AccountBalance map[string]*WalletAccountBalance `protobuf:"bytes,4,rep,name=account_balance,json=accountBalance,proto3" json:"account_balance,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *WalletBalanceResponse) Reset() { *x = WalletBalanceResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *WalletBalanceResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*WalletBalanceResponse) ProtoMessage() {} func (x *WalletBalanceResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use WalletBalanceResponse.ProtoReflect.Descriptor instead. func (*WalletBalanceResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{84} } func (x *WalletBalanceResponse) GetTotalBalance() int64 { if x != nil { return x.TotalBalance } return 0 } func (x *WalletBalanceResponse) GetConfirmedBalance() int64 { if x != nil { return x.ConfirmedBalance } return 0 } func (x *WalletBalanceResponse) GetUnconfirmedBalance() int64 { if x != nil { return x.UnconfirmedBalance } return 0 } func (x *WalletBalanceResponse) GetAccountBalance() map[string]*WalletAccountBalance { if x != nil { return x.AccountBalance } return nil } type Amount struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Value denominated in satoshis. Sat uint64 `protobuf:"varint,1,opt,name=sat,proto3" json:"sat,omitempty"` // Value denominated in milli-satoshis. Msat uint64 `protobuf:"varint,2,opt,name=msat,proto3" json:"msat,omitempty"` } func (x *Amount) Reset() { *x = Amount{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Amount) String() string { return protoimpl.X.MessageStringOf(x) } func (*Amount) ProtoMessage() {} func (x *Amount) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Amount.ProtoReflect.Descriptor instead. func (*Amount) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{85} } func (x *Amount) GetSat() uint64 { if x != nil { return x.Sat } return 0 } func (x *Amount) GetMsat() uint64 { if x != nil { return x.Msat } return 0 } type ChannelBalanceRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ChannelBalanceRequest) Reset() { *x = ChannelBalanceRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelBalanceRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelBalanceRequest) ProtoMessage() {} func (x *ChannelBalanceRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelBalanceRequest.ProtoReflect.Descriptor instead. func (*ChannelBalanceRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{86} } type ChannelBalanceResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Deprecated. Sum of channels balances denominated in satoshis // // Deprecated: Do not use. Balance int64 `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty"` // Deprecated. Sum of channels pending balances denominated in satoshis // // Deprecated: Do not use. PendingOpenBalance int64 `protobuf:"varint,2,opt,name=pending_open_balance,json=pendingOpenBalance,proto3" json:"pending_open_balance,omitempty"` // Sum of channels local balances. LocalBalance *Amount `protobuf:"bytes,3,opt,name=local_balance,json=localBalance,proto3" json:"local_balance,omitempty"` // Sum of channels remote balances. RemoteBalance *Amount `protobuf:"bytes,4,opt,name=remote_balance,json=remoteBalance,proto3" json:"remote_balance,omitempty"` // Sum of channels local unsettled balances. UnsettledLocalBalance *Amount `protobuf:"bytes,5,opt,name=unsettled_local_balance,json=unsettledLocalBalance,proto3" json:"unsettled_local_balance,omitempty"` // Sum of channels remote unsettled balances. UnsettledRemoteBalance *Amount `protobuf:"bytes,6,opt,name=unsettled_remote_balance,json=unsettledRemoteBalance,proto3" json:"unsettled_remote_balance,omitempty"` // Sum of channels pending local balances. PendingOpenLocalBalance *Amount `protobuf:"bytes,7,opt,name=pending_open_local_balance,json=pendingOpenLocalBalance,proto3" json:"pending_open_local_balance,omitempty"` // Sum of channels pending remote balances. PendingOpenRemoteBalance *Amount `protobuf:"bytes,8,opt,name=pending_open_remote_balance,json=pendingOpenRemoteBalance,proto3" json:"pending_open_remote_balance,omitempty"` } func (x *ChannelBalanceResponse) Reset() { *x = ChannelBalanceResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelBalanceResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelBalanceResponse) ProtoMessage() {} func (x *ChannelBalanceResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelBalanceResponse.ProtoReflect.Descriptor instead. func (*ChannelBalanceResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{87} } // Deprecated: Do not use. func (x *ChannelBalanceResponse) GetBalance() int64 { if x != nil { return x.Balance } return 0 } // Deprecated: Do not use. func (x *ChannelBalanceResponse) GetPendingOpenBalance() int64 { if x != nil { return x.PendingOpenBalance } return 0 } func (x *ChannelBalanceResponse) GetLocalBalance() *Amount { if x != nil { return x.LocalBalance } return nil } func (x *ChannelBalanceResponse) GetRemoteBalance() *Amount { if x != nil { return x.RemoteBalance } return nil } func (x *ChannelBalanceResponse) GetUnsettledLocalBalance() *Amount { if x != nil { return x.UnsettledLocalBalance } return nil } func (x *ChannelBalanceResponse) GetUnsettledRemoteBalance() *Amount { if x != nil { return x.UnsettledRemoteBalance } return nil } func (x *ChannelBalanceResponse) GetPendingOpenLocalBalance() *Amount { if x != nil { return x.PendingOpenLocalBalance } return nil } func (x *ChannelBalanceResponse) GetPendingOpenRemoteBalance() *Amount { if x != nil { return x.PendingOpenRemoteBalance } return nil } type QueryRoutesRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The 33-byte hex-encoded public key for the payment destination PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` // //The amount to send expressed in satoshis. // //The fields amt and amt_msat are mutually exclusive. Amt int64 `protobuf:"varint,2,opt,name=amt,proto3" json:"amt,omitempty"` // //The amount to send expressed in millisatoshis. // //The fields amt and amt_msat are mutually exclusive. AmtMsat int64 `protobuf:"varint,12,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"` // //An optional CLTV delta from the current height that should be used for the //timelock of the final hop. Note that unlike SendPayment, QueryRoutes does //not add any additional block padding on top of final_ctlv_delta. This //padding of a few blocks needs to be added manually or otherwise failures may //happen when a block comes in while the payment is in flight. FinalCltvDelta int32 `protobuf:"varint,4,opt,name=final_cltv_delta,json=finalCltvDelta,proto3" json:"final_cltv_delta,omitempty"` // //The maximum number of satoshis that will be paid as a fee of the payment. //This value can be represented either as a percentage of the amount being //sent, or as a fixed amount of the maximum fee the user is willing the pay to //send the payment. FeeLimit *FeeLimit `protobuf:"bytes,5,opt,name=fee_limit,json=feeLimit,proto3" json:"fee_limit,omitempty"` // //A list of nodes to ignore during path finding. When using REST, these fields //must be encoded as base64. IgnoredNodes [][]byte `protobuf:"bytes,6,rep,name=ignored_nodes,json=ignoredNodes,proto3" json:"ignored_nodes,omitempty"` // //Deprecated. A list of edges to ignore during path finding. // // Deprecated: Do not use. IgnoredEdges []*EdgeLocator `protobuf:"bytes,7,rep,name=ignored_edges,json=ignoredEdges,proto3" json:"ignored_edges,omitempty"` // //The source node where the request route should originated from. If empty, //self is assumed. SourcePubKey string `protobuf:"bytes,8,opt,name=source_pub_key,json=sourcePubKey,proto3" json:"source_pub_key,omitempty"` // //If set to true, edge probabilities from mission control will be used to get //the optimal route. UseMissionControl bool `protobuf:"varint,9,opt,name=use_mission_control,json=useMissionControl,proto3" json:"use_mission_control,omitempty"` // //A list of directed node pairs that will be ignored during path finding. IgnoredPairs []*NodePair `protobuf:"bytes,10,rep,name=ignored_pairs,json=ignoredPairs,proto3" json:"ignored_pairs,omitempty"` // //An optional maximum total time lock for the route. If the source is empty or //ourselves, this should not exceed lnd's `--max-cltv-expiry` setting. If //zero, then the value of `--max-cltv-expiry` is used as the limit. CltvLimit uint32 `protobuf:"varint,11,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,omitempty"` // //An optional field that can be used to pass an arbitrary set of TLV records //to a peer which understands the new records. This can be used to pass //application specific data during the payment attempt. If the destination //does not support the specified records, an error will be returned. //Record types are required to be in the custom range >= 65536. When using //REST, the values must be encoded as base64. DestCustomRecords map[uint64][]byte `protobuf:"bytes,13,rep,name=dest_custom_records,json=destCustomRecords,proto3" json:"dest_custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // //The channel id of the channel that must be taken to the first hop. If zero, //any channel may be used. OutgoingChanId uint64 `protobuf:"varint,14,opt,name=outgoing_chan_id,json=outgoingChanId,proto3" json:"outgoing_chan_id,omitempty"` // //The pubkey of the last hop of the route. If empty, any hop may be used. LastHopPubkey []byte `protobuf:"bytes,15,opt,name=last_hop_pubkey,json=lastHopPubkey,proto3" json:"last_hop_pubkey,omitempty"` // //Optional route hints to reach the destination through private channels. RouteHints []*RouteHint `protobuf:"bytes,16,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"` // //Features assumed to be supported by the final node. All transitive feature //dependencies must also be set properly. For a given feature bit pair, either //optional or remote may be set, but not both. If this field is nil or empty, //the router will try to load destination features from the graph as a //fallback. DestFeatures []FeatureBit `protobuf:"varint,17,rep,packed,name=dest_features,json=destFeatures,proto3,enum=lnrpc.FeatureBit" json:"dest_features,omitempty"` } func (x *QueryRoutesRequest) Reset() { *x = QueryRoutesRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *QueryRoutesRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*QueryRoutesRequest) ProtoMessage() {} func (x *QueryRoutesRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use QueryRoutesRequest.ProtoReflect.Descriptor instead. func (*QueryRoutesRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{88} } func (x *QueryRoutesRequest) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *QueryRoutesRequest) GetAmt() int64 { if x != nil { return x.Amt } return 0 } func (x *QueryRoutesRequest) GetAmtMsat() int64 { if x != nil { return x.AmtMsat } return 0 } func (x *QueryRoutesRequest) GetFinalCltvDelta() int32 { if x != nil { return x.FinalCltvDelta } return 0 } func (x *QueryRoutesRequest) GetFeeLimit() *FeeLimit { if x != nil { return x.FeeLimit } return nil } func (x *QueryRoutesRequest) GetIgnoredNodes() [][]byte { if x != nil { return x.IgnoredNodes } return nil } // Deprecated: Do not use. func (x *QueryRoutesRequest) GetIgnoredEdges() []*EdgeLocator { if x != nil { return x.IgnoredEdges } return nil } func (x *QueryRoutesRequest) GetSourcePubKey() string { if x != nil { return x.SourcePubKey } return "" } func (x *QueryRoutesRequest) GetUseMissionControl() bool { if x != nil { return x.UseMissionControl } return false } func (x *QueryRoutesRequest) GetIgnoredPairs() []*NodePair { if x != nil { return x.IgnoredPairs } return nil } func (x *QueryRoutesRequest) GetCltvLimit() uint32 { if x != nil { return x.CltvLimit } return 0 } func (x *QueryRoutesRequest) GetDestCustomRecords() map[uint64][]byte { if x != nil { return x.DestCustomRecords } return nil } func (x *QueryRoutesRequest) GetOutgoingChanId() uint64 { if x != nil { return x.OutgoingChanId } return 0 } func (x *QueryRoutesRequest) GetLastHopPubkey() []byte { if x != nil { return x.LastHopPubkey } return nil } func (x *QueryRoutesRequest) GetRouteHints() []*RouteHint { if x != nil { return x.RouteHints } return nil } func (x *QueryRoutesRequest) GetDestFeatures() []FeatureBit { if x != nil { return x.DestFeatures } return nil } type NodePair struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The sending node of the pair. When using REST, this field must be encoded as //base64. From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` // //The receiving node of the pair. When using REST, this field must be encoded //as base64. To []byte `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` } func (x *NodePair) Reset() { *x = NodePair{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodePair) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodePair) ProtoMessage() {} func (x *NodePair) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodePair.ProtoReflect.Descriptor instead. func (*NodePair) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{89} } func (x *NodePair) GetFrom() []byte { if x != nil { return x.From } return nil } func (x *NodePair) GetTo() []byte { if x != nil { return x.To } return nil } type EdgeLocator struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The short channel id of this edge. ChannelId uint64 `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` // //The direction of this edge. If direction_reverse is false, the direction //of this edge is from the channel endpoint with the lexicographically smaller //pub key to the endpoint with the larger pub key. If direction_reverse is //is true, the edge goes the other way. DirectionReverse bool `protobuf:"varint,2,opt,name=direction_reverse,json=directionReverse,proto3" json:"direction_reverse,omitempty"` } func (x *EdgeLocator) Reset() { *x = EdgeLocator{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *EdgeLocator) String() string { return protoimpl.X.MessageStringOf(x) } func (*EdgeLocator) ProtoMessage() {} func (x *EdgeLocator) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use EdgeLocator.ProtoReflect.Descriptor instead. func (*EdgeLocator) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{90} } func (x *EdgeLocator) GetChannelId() uint64 { if x != nil { return x.ChannelId } return 0 } func (x *EdgeLocator) GetDirectionReverse() bool { if x != nil { return x.DirectionReverse } return false } type QueryRoutesResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The route that results from the path finding operation. This is still a //repeated field to retain backwards compatibility. Routes []*Route `protobuf:"bytes,1,rep,name=routes,proto3" json:"routes,omitempty"` // //The success probability of the returned route based on the current mission //control state. [EXPERIMENTAL] SuccessProb float64 `protobuf:"fixed64,2,opt,name=success_prob,json=successProb,proto3" json:"success_prob,omitempty"` } func (x *QueryRoutesResponse) Reset() { *x = QueryRoutesResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *QueryRoutesResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*QueryRoutesResponse) ProtoMessage() {} func (x *QueryRoutesResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use QueryRoutesResponse.ProtoReflect.Descriptor instead. func (*QueryRoutesResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{91} } func (x *QueryRoutesResponse) GetRoutes() []*Route { if x != nil { return x.Routes } return nil } func (x *QueryRoutesResponse) GetSuccessProb() float64 { if x != nil { return x.SuccessProb } return 0 } type Hop struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // Deprecated: Do not use. ChanCapacity int64 `protobuf:"varint,2,opt,name=chan_capacity,json=chanCapacity,proto3" json:"chan_capacity,omitempty"` // Deprecated: Do not use. AmtToForward int64 `protobuf:"varint,3,opt,name=amt_to_forward,json=amtToForward,proto3" json:"amt_to_forward,omitempty"` // Deprecated: Do not use. Fee int64 `protobuf:"varint,4,opt,name=fee,proto3" json:"fee,omitempty"` Expiry uint32 `protobuf:"varint,5,opt,name=expiry,proto3" json:"expiry,omitempty"` AmtToForwardMsat int64 `protobuf:"varint,6,opt,name=amt_to_forward_msat,json=amtToForwardMsat,proto3" json:"amt_to_forward_msat,omitempty"` FeeMsat int64 `protobuf:"varint,7,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` // //An optional public key of the hop. If the public key is given, the payment //can be executed without relying on a copy of the channel graph. PubKey string `protobuf:"bytes,8,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` // //If set to true, then this hop will be encoded using the new variable length //TLV format. Note that if any custom tlv_records below are specified, then //this field MUST be set to true for them to be encoded properly. TlvPayload bool `protobuf:"varint,9,opt,name=tlv_payload,json=tlvPayload,proto3" json:"tlv_payload,omitempty"` // //An optional TLV record that signals the use of an MPP payment. If present, //the receiver will enforce that the same mpp_record is included in the final //hop payload of all non-zero payments in the HTLC set. If empty, a regular //single-shot payment is or was attempted. MppRecord *MPPRecord `protobuf:"bytes,10,opt,name=mpp_record,json=mppRecord,proto3" json:"mpp_record,omitempty"` // //An optional TLV record that signals the use of an AMP payment. If present, //the receiver will treat all received payments including the same //(payment_addr, set_id) pair as being part of one logical payment. The //payment will be settled by XORing the root_share's together and deriving the //child hashes and preimages according to BOLT XX. Must be used in conjunction //with mpp_record. AmpRecord *AMPRecord `protobuf:"bytes,12,opt,name=amp_record,json=ampRecord,proto3" json:"amp_record,omitempty"` // //An optional set of key-value TLV records. This is useful within the context //of the SendToRoute call as it allows callers to specify arbitrary K-V pairs //to drop off at each hop within the onion. CustomRecords map[uint64][]byte `protobuf:"bytes,11,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *Hop) Reset() { *x = Hop{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Hop) String() string { return protoimpl.X.MessageStringOf(x) } func (*Hop) ProtoMessage() {} func (x *Hop) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[92] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Hop.ProtoReflect.Descriptor instead. func (*Hop) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{92} } func (x *Hop) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } // Deprecated: Do not use. func (x *Hop) GetChanCapacity() int64 { if x != nil { return x.ChanCapacity } return 0 } // Deprecated: Do not use. func (x *Hop) GetAmtToForward() int64 { if x != nil { return x.AmtToForward } return 0 } // Deprecated: Do not use. func (x *Hop) GetFee() int64 { if x != nil { return x.Fee } return 0 } func (x *Hop) GetExpiry() uint32 { if x != nil { return x.Expiry } return 0 } func (x *Hop) GetAmtToForwardMsat() int64 { if x != nil { return x.AmtToForwardMsat } return 0 } func (x *Hop) GetFeeMsat() int64 { if x != nil { return x.FeeMsat } return 0 } func (x *Hop) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *Hop) GetTlvPayload() bool { if x != nil { return x.TlvPayload } return false } func (x *Hop) GetMppRecord() *MPPRecord { if x != nil { return x.MppRecord } return nil } func (x *Hop) GetAmpRecord() *AMPRecord { if x != nil { return x.AmpRecord } return nil } func (x *Hop) GetCustomRecords() map[uint64][]byte { if x != nil { return x.CustomRecords } return nil } type MPPRecord struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A unique, random identifier used to authenticate the sender as the intended //payer of a multi-path payment. The payment_addr must be the same for all //subpayments, and match the payment_addr provided in the receiver's invoice. //The same payment_addr must be used on all subpayments. PaymentAddr []byte `protobuf:"bytes,11,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` // //The total amount in milli-satoshis being sent as part of a larger multi-path //payment. The caller is responsible for ensuring subpayments to the same node //and payment_hash sum exactly to total_amt_msat. The same //total_amt_msat must be used on all subpayments. TotalAmtMsat int64 `protobuf:"varint,10,opt,name=total_amt_msat,json=totalAmtMsat,proto3" json:"total_amt_msat,omitempty"` } func (x *MPPRecord) Reset() { *x = MPPRecord{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MPPRecord) String() string { return protoimpl.X.MessageStringOf(x) } func (*MPPRecord) ProtoMessage() {} func (x *MPPRecord) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[93] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MPPRecord.ProtoReflect.Descriptor instead. func (*MPPRecord) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{93} } func (x *MPPRecord) GetPaymentAddr() []byte { if x != nil { return x.PaymentAddr } return nil } func (x *MPPRecord) GetTotalAmtMsat() int64 { if x != nil { return x.TotalAmtMsat } return 0 } type AMPRecord struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields RootShare []byte `protobuf:"bytes,1,opt,name=root_share,json=rootShare,proto3" json:"root_share,omitempty"` SetId []byte `protobuf:"bytes,2,opt,name=set_id,json=setId,proto3" json:"set_id,omitempty"` ChildIndex uint32 `protobuf:"varint,3,opt,name=child_index,json=childIndex,proto3" json:"child_index,omitempty"` } func (x *AMPRecord) Reset() { *x = AMPRecord{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AMPRecord) String() string { return protoimpl.X.MessageStringOf(x) } func (*AMPRecord) ProtoMessage() {} func (x *AMPRecord) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[94] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AMPRecord.ProtoReflect.Descriptor instead. func (*AMPRecord) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{94} } func (x *AMPRecord) GetRootShare() []byte { if x != nil { return x.RootShare } return nil } func (x *AMPRecord) GetSetId() []byte { if x != nil { return x.SetId } return nil } func (x *AMPRecord) GetChildIndex() uint32 { if x != nil { return x.ChildIndex } return 0 } // //A path through the channel graph which runs over one or more channels in //succession. This struct carries all the information required to craft the //Sphinx onion packet, and send the payment along the first hop in the path. A //route is only selected as valid if all the channels have sufficient capacity to //carry the initial payment amount after fees are accounted for. type Route struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The cumulative (final) time lock across the entire route. This is the CLTV //value that should be extended to the first hop in the route. All other hops //will decrement the time-lock as advertised, leaving enough time for all //hops to wait for or present the payment preimage to complete the payment. TotalTimeLock uint32 `protobuf:"varint,1,opt,name=total_time_lock,json=totalTimeLock,proto3" json:"total_time_lock,omitempty"` // //The sum of the fees paid at each hop within the final route. In the case //of a one-hop payment, this value will be zero as we don't need to pay a fee //to ourselves. // // Deprecated: Do not use. TotalFees int64 `protobuf:"varint,2,opt,name=total_fees,json=totalFees,proto3" json:"total_fees,omitempty"` // //The total amount of funds required to complete a payment over this route. //This value includes the cumulative fees at each hop. As a result, the HTLC //extended to the first-hop in the route will need to have at least this many //satoshis, otherwise the route will fail at an intermediate node due to an //insufficient amount of fees. // // Deprecated: Do not use. TotalAmt int64 `protobuf:"varint,3,opt,name=total_amt,json=totalAmt,proto3" json:"total_amt,omitempty"` // //Contains details concerning the specific forwarding details at each hop. Hops []*Hop `protobuf:"bytes,4,rep,name=hops,proto3" json:"hops,omitempty"` // //The total fees in millisatoshis. TotalFeesMsat int64 `protobuf:"varint,5,opt,name=total_fees_msat,json=totalFeesMsat,proto3" json:"total_fees_msat,omitempty"` // //The total amount in millisatoshis. TotalAmtMsat int64 `protobuf:"varint,6,opt,name=total_amt_msat,json=totalAmtMsat,proto3" json:"total_amt_msat,omitempty"` } func (x *Route) Reset() { *x = Route{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Route) String() string { return protoimpl.X.MessageStringOf(x) } func (*Route) ProtoMessage() {} func (x *Route) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[95] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Route.ProtoReflect.Descriptor instead. func (*Route) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{95} } func (x *Route) GetTotalTimeLock() uint32 { if x != nil { return x.TotalTimeLock } return 0 } // Deprecated: Do not use. func (x *Route) GetTotalFees() int64 { if x != nil { return x.TotalFees } return 0 } // Deprecated: Do not use. func (x *Route) GetTotalAmt() int64 { if x != nil { return x.TotalAmt } return 0 } func (x *Route) GetHops() []*Hop { if x != nil { return x.Hops } return nil } func (x *Route) GetTotalFeesMsat() int64 { if x != nil { return x.TotalFeesMsat } return 0 } func (x *Route) GetTotalAmtMsat() int64 { if x != nil { return x.TotalAmtMsat } return 0 } type NodeInfoRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The 33-byte hex-encoded compressed public of the target node PubKey string `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` // If true, will include all known channels associated with the node. IncludeChannels bool `protobuf:"varint,2,opt,name=include_channels,json=includeChannels,proto3" json:"include_channels,omitempty"` } func (x *NodeInfoRequest) Reset() { *x = NodeInfoRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeInfoRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeInfoRequest) ProtoMessage() {} func (x *NodeInfoRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[96] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeInfoRequest.ProtoReflect.Descriptor instead. func (*NodeInfoRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{96} } func (x *NodeInfoRequest) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *NodeInfoRequest) GetIncludeChannels() bool { if x != nil { return x.IncludeChannels } return false } type NodeInfo struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //An individual vertex/node within the channel graph. A node is //connected to other nodes by one or more channel edges emanating from it. As //the graph is directed, a node will also have an incoming edge attached to //it for each outgoing edge. Node *LightningNode `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"` // The total number of channels for the node. NumChannels uint32 `protobuf:"varint,2,opt,name=num_channels,json=numChannels,proto3" json:"num_channels,omitempty"` // The sum of all channels capacity for the node, denominated in satoshis. TotalCapacity int64 `protobuf:"varint,3,opt,name=total_capacity,json=totalCapacity,proto3" json:"total_capacity,omitempty"` // A list of all public channels for the node. Channels []*ChannelEdge `protobuf:"bytes,4,rep,name=channels,proto3" json:"channels,omitempty"` } func (x *NodeInfo) Reset() { *x = NodeInfo{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeInfo) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeInfo) ProtoMessage() {} func (x *NodeInfo) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeInfo.ProtoReflect.Descriptor instead. func (*NodeInfo) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{97} } func (x *NodeInfo) GetNode() *LightningNode { if x != nil { return x.Node } return nil } func (x *NodeInfo) GetNumChannels() uint32 { if x != nil { return x.NumChannels } return 0 } func (x *NodeInfo) GetTotalCapacity() int64 { if x != nil { return x.TotalCapacity } return 0 } func (x *NodeInfo) GetChannels() []*ChannelEdge { if x != nil { return x.Channels } return nil } // //An individual vertex/node within the channel graph. A node is //connected to other nodes by one or more channel edges emanating from it. As the //graph is directed, a node will also have an incoming edge attached to it for //each outgoing edge. type LightningNode struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields LastUpdate uint32 `protobuf:"varint,1,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` PubKey string `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"` Alias string `protobuf:"bytes,3,opt,name=alias,proto3" json:"alias,omitempty"` Addresses []*NodeAddress `protobuf:"bytes,4,rep,name=addresses,proto3" json:"addresses,omitempty"` Color string `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"` Features map[uint32]*Feature `protobuf:"bytes,6,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *LightningNode) Reset() { *x = LightningNode{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *LightningNode) String() string { return protoimpl.X.MessageStringOf(x) } func (*LightningNode) ProtoMessage() {} func (x *LightningNode) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use LightningNode.ProtoReflect.Descriptor instead. func (*LightningNode) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{98} } func (x *LightningNode) GetLastUpdate() uint32 { if x != nil { return x.LastUpdate } return 0 } func (x *LightningNode) GetPubKey() string { if x != nil { return x.PubKey } return "" } func (x *LightningNode) GetAlias() string { if x != nil { return x.Alias } return "" } func (x *LightningNode) GetAddresses() []*NodeAddress { if x != nil { return x.Addresses } return nil } func (x *LightningNode) GetColor() string { if x != nil { return x.Color } return "" } func (x *LightningNode) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } type NodeAddress struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Network string `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"` Addr string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"` } func (x *NodeAddress) Reset() { *x = NodeAddress{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeAddress) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeAddress) ProtoMessage() {} func (x *NodeAddress) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeAddress.ProtoReflect.Descriptor instead. func (*NodeAddress) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{99} } func (x *NodeAddress) GetNetwork() string { if x != nil { return x.Network } return "" } func (x *NodeAddress) GetAddr() string { if x != nil { return x.Addr } return "" } type RoutingPolicy struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields TimeLockDelta uint32 `protobuf:"varint,1,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` MinHtlc int64 `protobuf:"varint,2,opt,name=min_htlc,json=minHtlc,proto3" json:"min_htlc,omitempty"` FeeBaseMsat int64 `protobuf:"varint,3,opt,name=fee_base_msat,json=feeBaseMsat,proto3" json:"fee_base_msat,omitempty"` FeeRateMilliMsat int64 `protobuf:"varint,4,opt,name=fee_rate_milli_msat,json=feeRateMilliMsat,proto3" json:"fee_rate_milli_msat,omitempty"` Disabled bool `protobuf:"varint,5,opt,name=disabled,proto3" json:"disabled,omitempty"` MaxHtlcMsat uint64 `protobuf:"varint,6,opt,name=max_htlc_msat,json=maxHtlcMsat,proto3" json:"max_htlc_msat,omitempty"` LastUpdate uint32 `protobuf:"varint,7,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` } func (x *RoutingPolicy) Reset() { *x = RoutingPolicy{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RoutingPolicy) String() string { return protoimpl.X.MessageStringOf(x) } func (*RoutingPolicy) ProtoMessage() {} func (x *RoutingPolicy) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RoutingPolicy.ProtoReflect.Descriptor instead. func (*RoutingPolicy) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{100} } func (x *RoutingPolicy) GetTimeLockDelta() uint32 { if x != nil { return x.TimeLockDelta } return 0 } func (x *RoutingPolicy) GetMinHtlc() int64 { if x != nil { return x.MinHtlc } return 0 } func (x *RoutingPolicy) GetFeeBaseMsat() int64 { if x != nil { return x.FeeBaseMsat } return 0 } func (x *RoutingPolicy) GetFeeRateMilliMsat() int64 { if x != nil { return x.FeeRateMilliMsat } return 0 } func (x *RoutingPolicy) GetDisabled() bool { if x != nil { return x.Disabled } return false } func (x *RoutingPolicy) GetMaxHtlcMsat() uint64 { if x != nil { return x.MaxHtlcMsat } return 0 } func (x *RoutingPolicy) GetLastUpdate() uint32 { if x != nil { return x.LastUpdate } return 0 } // //A fully authenticated channel along with all its unique attributes. //Once an authenticated channel announcement has been processed on the network, //then an instance of ChannelEdgeInfo encapsulating the channels attributes is //stored. The other portions relevant to routing policy of a channel are stored //within a ChannelEdgePolicy for each direction of the channel. type ChannelEdge struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChannelId uint64 `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"` ChanPoint string `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` // Deprecated: Do not use. LastUpdate uint32 `protobuf:"varint,3,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"` Node1Pub string `protobuf:"bytes,4,opt,name=node1_pub,json=node1Pub,proto3" json:"node1_pub,omitempty"` Node2Pub string `protobuf:"bytes,5,opt,name=node2_pub,json=node2Pub,proto3" json:"node2_pub,omitempty"` Capacity int64 `protobuf:"varint,6,opt,name=capacity,proto3" json:"capacity,omitempty"` Node1Policy *RoutingPolicy `protobuf:"bytes,7,opt,name=node1_policy,json=node1Policy,proto3" json:"node1_policy,omitempty"` Node2Policy *RoutingPolicy `protobuf:"bytes,8,opt,name=node2_policy,json=node2Policy,proto3" json:"node2_policy,omitempty"` } func (x *ChannelEdge) Reset() { *x = ChannelEdge{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelEdge) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelEdge) ProtoMessage() {} func (x *ChannelEdge) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelEdge.ProtoReflect.Descriptor instead. func (*ChannelEdge) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{101} } func (x *ChannelEdge) GetChannelId() uint64 { if x != nil { return x.ChannelId } return 0 } func (x *ChannelEdge) GetChanPoint() string { if x != nil { return x.ChanPoint } return "" } // Deprecated: Do not use. func (x *ChannelEdge) GetLastUpdate() uint32 { if x != nil { return x.LastUpdate } return 0 } func (x *ChannelEdge) GetNode1Pub() string { if x != nil { return x.Node1Pub } return "" } func (x *ChannelEdge) GetNode2Pub() string { if x != nil { return x.Node2Pub } return "" } func (x *ChannelEdge) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *ChannelEdge) GetNode1Policy() *RoutingPolicy { if x != nil { return x.Node1Policy } return nil } func (x *ChannelEdge) GetNode2Policy() *RoutingPolicy { if x != nil { return x.Node2Policy } return nil } type ChannelGraphRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //Whether unannounced channels are included in the response or not. If set, //unannounced channels are included. Unannounced channels are both private //channels, and public channels that are not yet announced to the network. IncludeUnannounced bool `protobuf:"varint,1,opt,name=include_unannounced,json=includeUnannounced,proto3" json:"include_unannounced,omitempty"` } func (x *ChannelGraphRequest) Reset() { *x = ChannelGraphRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelGraphRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelGraphRequest) ProtoMessage() {} func (x *ChannelGraphRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelGraphRequest.ProtoReflect.Descriptor instead. func (*ChannelGraphRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{102} } func (x *ChannelGraphRequest) GetIncludeUnannounced() bool { if x != nil { return x.IncludeUnannounced } return false } // Returns a new instance of the directed channel graph. type ChannelGraph struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of `LightningNode`s in this channel graph Nodes []*LightningNode `protobuf:"bytes,1,rep,name=nodes,proto3" json:"nodes,omitempty"` // The list of `ChannelEdge`s in this channel graph Edges []*ChannelEdge `protobuf:"bytes,2,rep,name=edges,proto3" json:"edges,omitempty"` } func (x *ChannelGraph) Reset() { *x = ChannelGraph{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelGraph) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelGraph) ProtoMessage() {} func (x *ChannelGraph) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelGraph.ProtoReflect.Descriptor instead. func (*ChannelGraph) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{103} } func (x *ChannelGraph) GetNodes() []*LightningNode { if x != nil { return x.Nodes } return nil } func (x *ChannelGraph) GetEdges() []*ChannelEdge { if x != nil { return x.Edges } return nil } type NodeMetricsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The requested node metrics. Types []NodeMetricType `protobuf:"varint,1,rep,packed,name=types,proto3,enum=lnrpc.NodeMetricType" json:"types,omitempty"` } func (x *NodeMetricsRequest) Reset() { *x = NodeMetricsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeMetricsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeMetricsRequest) ProtoMessage() {} func (x *NodeMetricsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeMetricsRequest.ProtoReflect.Descriptor instead. func (*NodeMetricsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{104} } func (x *NodeMetricsRequest) GetTypes() []NodeMetricType { if x != nil { return x.Types } return nil } type NodeMetricsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //Betweenness centrality is the sum of the ratio of shortest paths that pass //through the node for each pair of nodes in the graph (not counting paths //starting or ending at this node). //Map of node pubkey to betweenness centrality of the node. Normalized //values are in the [0,1] closed interval. BetweennessCentrality map[string]*FloatMetric `protobuf:"bytes,1,rep,name=betweenness_centrality,json=betweennessCentrality,proto3" json:"betweenness_centrality,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *NodeMetricsResponse) Reset() { *x = NodeMetricsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeMetricsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeMetricsResponse) ProtoMessage() {} func (x *NodeMetricsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeMetricsResponse.ProtoReflect.Descriptor instead. func (*NodeMetricsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{105} } func (x *NodeMetricsResponse) GetBetweennessCentrality() map[string]*FloatMetric { if x != nil { return x.BetweennessCentrality } return nil } type FloatMetric struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Arbitrary float value. Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"` // The value normalized to [0,1] or [-1,1]. NormalizedValue float64 `protobuf:"fixed64,2,opt,name=normalized_value,json=normalizedValue,proto3" json:"normalized_value,omitempty"` } func (x *FloatMetric) Reset() { *x = FloatMetric{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FloatMetric) String() string { return protoimpl.X.MessageStringOf(x) } func (*FloatMetric) ProtoMessage() {} func (x *FloatMetric) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FloatMetric.ProtoReflect.Descriptor instead. func (*FloatMetric) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{106} } func (x *FloatMetric) GetValue() float64 { if x != nil { return x.Value } return 0 } func (x *FloatMetric) GetNormalizedValue() float64 { if x != nil { return x.NormalizedValue } return 0 } type ChanInfoRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` } func (x *ChanInfoRequest) Reset() { *x = ChanInfoRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChanInfoRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChanInfoRequest) ProtoMessage() {} func (x *ChanInfoRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChanInfoRequest.ProtoReflect.Descriptor instead. func (*ChanInfoRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{107} } func (x *ChanInfoRequest) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } type NetworkInfoRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *NetworkInfoRequest) Reset() { *x = NetworkInfoRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NetworkInfoRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*NetworkInfoRequest) ProtoMessage() {} func (x *NetworkInfoRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NetworkInfoRequest.ProtoReflect.Descriptor instead. func (*NetworkInfoRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{108} } type NetworkInfo struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields GraphDiameter uint32 `protobuf:"varint,1,opt,name=graph_diameter,json=graphDiameter,proto3" json:"graph_diameter,omitempty"` AvgOutDegree float64 `protobuf:"fixed64,2,opt,name=avg_out_degree,json=avgOutDegree,proto3" json:"avg_out_degree,omitempty"` MaxOutDegree uint32 `protobuf:"varint,3,opt,name=max_out_degree,json=maxOutDegree,proto3" json:"max_out_degree,omitempty"` NumNodes uint32 `protobuf:"varint,4,opt,name=num_nodes,json=numNodes,proto3" json:"num_nodes,omitempty"` NumChannels uint32 `protobuf:"varint,5,opt,name=num_channels,json=numChannels,proto3" json:"num_channels,omitempty"` TotalNetworkCapacity int64 `protobuf:"varint,6,opt,name=total_network_capacity,json=totalNetworkCapacity,proto3" json:"total_network_capacity,omitempty"` AvgChannelSize float64 `protobuf:"fixed64,7,opt,name=avg_channel_size,json=avgChannelSize,proto3" json:"avg_channel_size,omitempty"` MinChannelSize int64 `protobuf:"varint,8,opt,name=min_channel_size,json=minChannelSize,proto3" json:"min_channel_size,omitempty"` MaxChannelSize int64 `protobuf:"varint,9,opt,name=max_channel_size,json=maxChannelSize,proto3" json:"max_channel_size,omitempty"` MedianChannelSizeSat int64 `protobuf:"varint,10,opt,name=median_channel_size_sat,json=medianChannelSizeSat,proto3" json:"median_channel_size_sat,omitempty"` // The number of edges marked as zombies. NumZombieChans uint64 `protobuf:"varint,11,opt,name=num_zombie_chans,json=numZombieChans,proto3" json:"num_zombie_chans,omitempty"` } func (x *NetworkInfo) Reset() { *x = NetworkInfo{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NetworkInfo) String() string { return protoimpl.X.MessageStringOf(x) } func (*NetworkInfo) ProtoMessage() {} func (x *NetworkInfo) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NetworkInfo.ProtoReflect.Descriptor instead. func (*NetworkInfo) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{109} } func (x *NetworkInfo) GetGraphDiameter() uint32 { if x != nil { return x.GraphDiameter } return 0 } func (x *NetworkInfo) GetAvgOutDegree() float64 { if x != nil { return x.AvgOutDegree } return 0 } func (x *NetworkInfo) GetMaxOutDegree() uint32 { if x != nil { return x.MaxOutDegree } return 0 } func (x *NetworkInfo) GetNumNodes() uint32 { if x != nil { return x.NumNodes } return 0 } func (x *NetworkInfo) GetNumChannels() uint32 { if x != nil { return x.NumChannels } return 0 } func (x *NetworkInfo) GetTotalNetworkCapacity() int64 { if x != nil { return x.TotalNetworkCapacity } return 0 } func (x *NetworkInfo) GetAvgChannelSize() float64 { if x != nil { return x.AvgChannelSize } return 0 } func (x *NetworkInfo) GetMinChannelSize() int64 { if x != nil { return x.MinChannelSize } return 0 } func (x *NetworkInfo) GetMaxChannelSize() int64 { if x != nil { return x.MaxChannelSize } return 0 } func (x *NetworkInfo) GetMedianChannelSizeSat() int64 { if x != nil { return x.MedianChannelSizeSat } return 0 } func (x *NetworkInfo) GetNumZombieChans() uint64 { if x != nil { return x.NumZombieChans } return 0 } type StopRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *StopRequest) Reset() { *x = StopRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *StopRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*StopRequest) ProtoMessage() {} func (x *StopRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use StopRequest.ProtoReflect.Descriptor instead. func (*StopRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{110} } type StopResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *StopResponse) Reset() { *x = StopResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *StopResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*StopResponse) ProtoMessage() {} func (x *StopResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use StopResponse.ProtoReflect.Descriptor instead. func (*StopResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{111} } type GraphTopologySubscription struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *GraphTopologySubscription) Reset() { *x = GraphTopologySubscription{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GraphTopologySubscription) String() string { return protoimpl.X.MessageStringOf(x) } func (*GraphTopologySubscription) ProtoMessage() {} func (x *GraphTopologySubscription) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GraphTopologySubscription.ProtoReflect.Descriptor instead. func (*GraphTopologySubscription) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{112} } type GraphTopologyUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields NodeUpdates []*NodeUpdate `protobuf:"bytes,1,rep,name=node_updates,json=nodeUpdates,proto3" json:"node_updates,omitempty"` ChannelUpdates []*ChannelEdgeUpdate `protobuf:"bytes,2,rep,name=channel_updates,json=channelUpdates,proto3" json:"channel_updates,omitempty"` ClosedChans []*ClosedChannelUpdate `protobuf:"bytes,3,rep,name=closed_chans,json=closedChans,proto3" json:"closed_chans,omitempty"` } func (x *GraphTopologyUpdate) Reset() { *x = GraphTopologyUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *GraphTopologyUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*GraphTopologyUpdate) ProtoMessage() {} func (x *GraphTopologyUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use GraphTopologyUpdate.ProtoReflect.Descriptor instead. func (*GraphTopologyUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{113} } func (x *GraphTopologyUpdate) GetNodeUpdates() []*NodeUpdate { if x != nil { return x.NodeUpdates } return nil } func (x *GraphTopologyUpdate) GetChannelUpdates() []*ChannelEdgeUpdate { if x != nil { return x.ChannelUpdates } return nil } func (x *GraphTopologyUpdate) GetClosedChans() []*ClosedChannelUpdate { if x != nil { return x.ClosedChans } return nil } type NodeUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //Deprecated, use node_addresses. // // Deprecated: Do not use. Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` IdentityKey string `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"` // //Deprecated, use features. // // Deprecated: Do not use. GlobalFeatures []byte `protobuf:"bytes,3,opt,name=global_features,json=globalFeatures,proto3" json:"global_features,omitempty"` Alias string `protobuf:"bytes,4,opt,name=alias,proto3" json:"alias,omitempty"` Color string `protobuf:"bytes,5,opt,name=color,proto3" json:"color,omitempty"` NodeAddresses []*NodeAddress `protobuf:"bytes,7,rep,name=node_addresses,json=nodeAddresses,proto3" json:"node_addresses,omitempty"` // //Features that the node has advertised in the init message, node //announcements and invoices. Features map[uint32]*Feature `protobuf:"bytes,6,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *NodeUpdate) Reset() { *x = NodeUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *NodeUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*NodeUpdate) ProtoMessage() {} func (x *NodeUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use NodeUpdate.ProtoReflect.Descriptor instead. func (*NodeUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{114} } // Deprecated: Do not use. func (x *NodeUpdate) GetAddresses() []string { if x != nil { return x.Addresses } return nil } func (x *NodeUpdate) GetIdentityKey() string { if x != nil { return x.IdentityKey } return "" } // Deprecated: Do not use. func (x *NodeUpdate) GetGlobalFeatures() []byte { if x != nil { return x.GlobalFeatures } return nil } func (x *NodeUpdate) GetAlias() string { if x != nil { return x.Alias } return "" } func (x *NodeUpdate) GetColor() string { if x != nil { return x.Color } return "" } func (x *NodeUpdate) GetNodeAddresses() []*NodeAddress { if x != nil { return x.NodeAddresses } return nil } func (x *NodeUpdate) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } type ChannelEdgeUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` Capacity int64 `protobuf:"varint,3,opt,name=capacity,proto3" json:"capacity,omitempty"` RoutingPolicy *RoutingPolicy `protobuf:"bytes,4,opt,name=routing_policy,json=routingPolicy,proto3" json:"routing_policy,omitempty"` AdvertisingNode string `protobuf:"bytes,5,opt,name=advertising_node,json=advertisingNode,proto3" json:"advertising_node,omitempty"` ConnectingNode string `protobuf:"bytes,6,opt,name=connecting_node,json=connectingNode,proto3" json:"connecting_node,omitempty"` } func (x *ChannelEdgeUpdate) Reset() { *x = ChannelEdgeUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelEdgeUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelEdgeUpdate) ProtoMessage() {} func (x *ChannelEdgeUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[115] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelEdgeUpdate.ProtoReflect.Descriptor instead. func (*ChannelEdgeUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{115} } func (x *ChannelEdgeUpdate) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *ChannelEdgeUpdate) GetChanPoint() *ChannelPoint { if x != nil { return x.ChanPoint } return nil } func (x *ChannelEdgeUpdate) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *ChannelEdgeUpdate) GetRoutingPolicy() *RoutingPolicy { if x != nil { return x.RoutingPolicy } return nil } func (x *ChannelEdgeUpdate) GetAdvertisingNode() string { if x != nil { return x.AdvertisingNode } return "" } func (x *ChannelEdgeUpdate) GetConnectingNode() string { if x != nil { return x.ConnectingNode } return "" } type ClosedChannelUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique channel ID for the channel. The first 3 bytes are the block //height, the next 3 the index within the block, and the last 2 bytes are the //output index for the channel. ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` Capacity int64 `protobuf:"varint,2,opt,name=capacity,proto3" json:"capacity,omitempty"` ClosedHeight uint32 `protobuf:"varint,3,opt,name=closed_height,json=closedHeight,proto3" json:"closed_height,omitempty"` ChanPoint *ChannelPoint `protobuf:"bytes,4,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` } func (x *ClosedChannelUpdate) Reset() { *x = ClosedChannelUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ClosedChannelUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ClosedChannelUpdate) ProtoMessage() {} func (x *ClosedChannelUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[116] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ClosedChannelUpdate.ProtoReflect.Descriptor instead. func (*ClosedChannelUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{116} } func (x *ClosedChannelUpdate) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *ClosedChannelUpdate) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *ClosedChannelUpdate) GetClosedHeight() uint32 { if x != nil { return x.ClosedHeight } return 0 } func (x *ClosedChannelUpdate) GetChanPoint() *ChannelPoint { if x != nil { return x.ChanPoint } return nil } type HopHint struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The public key of the node at the start of the channel. NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"` // The unique identifier of the channel. ChanId uint64 `protobuf:"varint,2,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // The base fee of the channel denominated in millisatoshis. FeeBaseMsat uint32 `protobuf:"varint,3,opt,name=fee_base_msat,json=feeBaseMsat,proto3" json:"fee_base_msat,omitempty"` // //The fee rate of the channel for sending one satoshi across it denominated in //millionths of a satoshi. FeeProportionalMillionths uint32 `protobuf:"varint,4,opt,name=fee_proportional_millionths,json=feeProportionalMillionths,proto3" json:"fee_proportional_millionths,omitempty"` // The time-lock delta of the channel. CltvExpiryDelta uint32 `protobuf:"varint,5,opt,name=cltv_expiry_delta,json=cltvExpiryDelta,proto3" json:"cltv_expiry_delta,omitempty"` } func (x *HopHint) Reset() { *x = HopHint{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *HopHint) String() string { return protoimpl.X.MessageStringOf(x) } func (*HopHint) ProtoMessage() {} func (x *HopHint) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[117] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use HopHint.ProtoReflect.Descriptor instead. func (*HopHint) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{117} } func (x *HopHint) GetNodeId() string { if x != nil { return x.NodeId } return "" } func (x *HopHint) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *HopHint) GetFeeBaseMsat() uint32 { if x != nil { return x.FeeBaseMsat } return 0 } func (x *HopHint) GetFeeProportionalMillionths() uint32 { if x != nil { return x.FeeProportionalMillionths } return 0 } func (x *HopHint) GetCltvExpiryDelta() uint32 { if x != nil { return x.CltvExpiryDelta } return 0 } type SetID struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields SetId []byte `protobuf:"bytes,1,opt,name=set_id,json=setId,proto3" json:"set_id,omitempty"` } func (x *SetID) Reset() { *x = SetID{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *SetID) String() string { return protoimpl.X.MessageStringOf(x) } func (*SetID) ProtoMessage() {} func (x *SetID) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[118] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use SetID.ProtoReflect.Descriptor instead. func (*SetID) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{118} } func (x *SetID) GetSetId() []byte { if x != nil { return x.SetId } return nil } type RouteHint struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A list of hop hints that when chained together can assist in reaching a //specific destination. HopHints []*HopHint `protobuf:"bytes,1,rep,name=hop_hints,json=hopHints,proto3" json:"hop_hints,omitempty"` } func (x *RouteHint) Reset() { *x = RouteHint{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RouteHint) String() string { return protoimpl.X.MessageStringOf(x) } func (*RouteHint) ProtoMessage() {} func (x *RouteHint) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[119] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RouteHint.ProtoReflect.Descriptor instead. func (*RouteHint) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{119} } func (x *RouteHint) GetHopHints() []*HopHint { if x != nil { return x.HopHints } return nil } type AMPInvoiceState struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The state the HTLCs associated with this setID are in. State InvoiceHTLCState `protobuf:"varint,1,opt,name=state,proto3,enum=lnrpc.InvoiceHTLCState" json:"state,omitempty"` // The settle index of this HTLC set, if the invoice state is settled. SettleIndex uint64 `protobuf:"varint,2,opt,name=settle_index,json=settleIndex,proto3" json:"settle_index,omitempty"` // The time this HTLC set was settled expressed in unix epoch. SettleTime int64 `protobuf:"varint,3,opt,name=settle_time,json=settleTime,proto3" json:"settle_time,omitempty"` // The total amount paid for the sub-invoice expressed in milli satoshis. AmtPaidMsat int64 `protobuf:"varint,5,opt,name=amt_paid_msat,json=amtPaidMsat,proto3" json:"amt_paid_msat,omitempty"` } func (x *AMPInvoiceState) Reset() { *x = AMPInvoiceState{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AMPInvoiceState) String() string { return protoimpl.X.MessageStringOf(x) } func (*AMPInvoiceState) ProtoMessage() {} func (x *AMPInvoiceState) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[120] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AMPInvoiceState.ProtoReflect.Descriptor instead. func (*AMPInvoiceState) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{120} } func (x *AMPInvoiceState) GetState() InvoiceHTLCState { if x != nil { return x.State } return InvoiceHTLCState_ACCEPTED } func (x *AMPInvoiceState) GetSettleIndex() uint64 { if x != nil { return x.SettleIndex } return 0 } func (x *AMPInvoiceState) GetSettleTime() int64 { if x != nil { return x.SettleTime } return 0 } func (x *AMPInvoiceState) GetAmtPaidMsat() int64 { if x != nil { return x.AmtPaidMsat } return 0 } type Invoice struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //An optional memo to attach along with the invoice. Used for record keeping //purposes for the invoice's creator, and will also be set in the description //field of the encoded payment request if the description_hash field is not //being used. Memo string `protobuf:"bytes,1,opt,name=memo,proto3" json:"memo,omitempty"` // //The hex-encoded preimage (32 byte) which will allow settling an incoming //HTLC payable to this preimage. When using REST, this field must be encoded //as base64. RPreimage []byte `protobuf:"bytes,3,opt,name=r_preimage,json=rPreimage,proto3" json:"r_preimage,omitempty"` // //The hash of the preimage. When using REST, this field must be encoded as //base64. RHash []byte `protobuf:"bytes,4,opt,name=r_hash,json=rHash,proto3" json:"r_hash,omitempty"` // //The value of this invoice in satoshis // //The fields value and value_msat are mutually exclusive. Value int64 `protobuf:"varint,5,opt,name=value,proto3" json:"value,omitempty"` // //The value of this invoice in millisatoshis // //The fields value and value_msat are mutually exclusive. ValueMsat int64 `protobuf:"varint,23,opt,name=value_msat,json=valueMsat,proto3" json:"value_msat,omitempty"` // Whether this invoice has been fulfilled // // Deprecated: Do not use. Settled bool `protobuf:"varint,6,opt,name=settled,proto3" json:"settled,omitempty"` // When this invoice was created CreationDate int64 `protobuf:"varint,7,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"` // When this invoice was settled SettleDate int64 `protobuf:"varint,8,opt,name=settle_date,json=settleDate,proto3" json:"settle_date,omitempty"` // //A bare-bones invoice for a payment within the Lightning Network. With the //details of the invoice, the sender has all the data necessary to send a //payment to the recipient. PaymentRequest string `protobuf:"bytes,9,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` // //Hash (SHA-256) of a description of the payment. Used if the description of //payment (memo) is too long to naturally fit within the description field //of an encoded payment request. When using REST, this field must be encoded //as base64. DescriptionHash []byte `protobuf:"bytes,10,opt,name=description_hash,json=descriptionHash,proto3" json:"description_hash,omitempty"` // Payment request expiry time in seconds. Default is 3600 (1 hour). Expiry int64 `protobuf:"varint,11,opt,name=expiry,proto3" json:"expiry,omitempty"` // Fallback on-chain address. FallbackAddr string `protobuf:"bytes,12,opt,name=fallback_addr,json=fallbackAddr,proto3" json:"fallback_addr,omitempty"` // Delta to use for the time-lock of the CLTV extended to the final hop. CltvExpiry uint64 `protobuf:"varint,13,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` // //Route hints that can each be individually used to assist in reaching the //invoice's destination. RouteHints []*RouteHint `protobuf:"bytes,14,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"` // Whether this invoice should include routing hints for private channels. Private bool `protobuf:"varint,15,opt,name=private,proto3" json:"private,omitempty"` // //The "add" index of this invoice. Each newly created invoice will increment //this index making it monotonically increasing. Callers to the //SubscribeInvoices call can use this to instantly get notified of all added //invoices with an add_index greater than this one. AddIndex uint64 `protobuf:"varint,16,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` // //The "settle" index of this invoice. Each newly settled invoice will //increment this index making it monotonically increasing. Callers to the //SubscribeInvoices call can use this to instantly get notified of all //settled invoices with an settle_index greater than this one. SettleIndex uint64 `protobuf:"varint,17,opt,name=settle_index,json=settleIndex,proto3" json:"settle_index,omitempty"` // Deprecated, use amt_paid_sat or amt_paid_msat. // // Deprecated: Do not use. AmtPaid int64 `protobuf:"varint,18,opt,name=amt_paid,json=amtPaid,proto3" json:"amt_paid,omitempty"` // //The amount that was accepted for this invoice, in satoshis. This will ONLY //be set if this invoice has been settled. We provide this field as if the //invoice was created with a zero value, then we need to record what amount //was ultimately accepted. Additionally, it's possible that the sender paid //MORE that was specified in the original invoice. So we'll record that here //as well. AmtPaidSat int64 `protobuf:"varint,19,opt,name=amt_paid_sat,json=amtPaidSat,proto3" json:"amt_paid_sat,omitempty"` // //The amount that was accepted for this invoice, in millisatoshis. This will //ONLY be set if this invoice has been settled. We provide this field as if //the invoice was created with a zero value, then we need to record what //amount was ultimately accepted. Additionally, it's possible that the sender //paid MORE that was specified in the original invoice. So we'll record that //here as well. AmtPaidMsat int64 `protobuf:"varint,20,opt,name=amt_paid_msat,json=amtPaidMsat,proto3" json:"amt_paid_msat,omitempty"` // //The state the invoice is in. State Invoice_InvoiceState `protobuf:"varint,21,opt,name=state,proto3,enum=lnrpc.Invoice_InvoiceState" json:"state,omitempty"` // List of HTLCs paying to this invoice [EXPERIMENTAL]. Htlcs []*InvoiceHTLC `protobuf:"bytes,22,rep,name=htlcs,proto3" json:"htlcs,omitempty"` // List of features advertised on the invoice. Features map[uint32]*Feature `protobuf:"bytes,24,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // //Indicates if this invoice was a spontaneous payment that arrived via keysend //[EXPERIMENTAL]. IsKeysend bool `protobuf:"varint,25,opt,name=is_keysend,json=isKeysend,proto3" json:"is_keysend,omitempty"` // //The payment address of this invoice. This value will be used in MPP //payments, and also for newer invoices that always require the MPP payload //for added end-to-end security. PaymentAddr []byte `protobuf:"bytes,26,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` // //Signals whether or not this is an AMP invoice. IsAmp bool `protobuf:"varint,27,opt,name=is_amp,json=isAmp,proto3" json:"is_amp,omitempty"` // //[EXPERIMENTAL]: // //Maps a 32-byte hex-encoded set ID to the sub-invoice AMP state for the //given set ID. This field is always populated for AMP invoices, and can be //used along side LookupInvoice to obtain the HTLC information related to a //given sub-invoice. AmpInvoiceState map[string]*AMPInvoiceState `protobuf:"bytes,28,rep,name=amp_invoice_state,json=ampInvoiceState,proto3" json:"amp_invoice_state,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *Invoice) Reset() { *x = Invoice{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Invoice) String() string { return protoimpl.X.MessageStringOf(x) } func (*Invoice) ProtoMessage() {} func (x *Invoice) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[121] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Invoice.ProtoReflect.Descriptor instead. func (*Invoice) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{121} } func (x *Invoice) GetMemo() string { if x != nil { return x.Memo } return "" } func (x *Invoice) GetRPreimage() []byte { if x != nil { return x.RPreimage } return nil } func (x *Invoice) GetRHash() []byte { if x != nil { return x.RHash } return nil } func (x *Invoice) GetValue() int64 { if x != nil { return x.Value } return 0 } func (x *Invoice) GetValueMsat() int64 { if x != nil { return x.ValueMsat } return 0 } // Deprecated: Do not use. func (x *Invoice) GetSettled() bool { if x != nil { return x.Settled } return false } func (x *Invoice) GetCreationDate() int64 { if x != nil { return x.CreationDate } return 0 } func (x *Invoice) GetSettleDate() int64 { if x != nil { return x.SettleDate } return 0 } func (x *Invoice) GetPaymentRequest() string { if x != nil { return x.PaymentRequest } return "" } func (x *Invoice) GetDescriptionHash() []byte { if x != nil { return x.DescriptionHash } return nil } func (x *Invoice) GetExpiry() int64 { if x != nil { return x.Expiry } return 0 } func (x *Invoice) GetFallbackAddr() string { if x != nil { return x.FallbackAddr } return "" } func (x *Invoice) GetCltvExpiry() uint64 { if x != nil { return x.CltvExpiry } return 0 } func (x *Invoice) GetRouteHints() []*RouteHint { if x != nil { return x.RouteHints } return nil } func (x *Invoice) GetPrivate() bool { if x != nil { return x.Private } return false } func (x *Invoice) GetAddIndex() uint64 { if x != nil { return x.AddIndex } return 0 } func (x *Invoice) GetSettleIndex() uint64 { if x != nil { return x.SettleIndex } return 0 } // Deprecated: Do not use. func (x *Invoice) GetAmtPaid() int64 { if x != nil { return x.AmtPaid } return 0 } func (x *Invoice) GetAmtPaidSat() int64 { if x != nil { return x.AmtPaidSat } return 0 } func (x *Invoice) GetAmtPaidMsat() int64 { if x != nil { return x.AmtPaidMsat } return 0 } func (x *Invoice) GetState() Invoice_InvoiceState { if x != nil { return x.State } return Invoice_OPEN } func (x *Invoice) GetHtlcs() []*InvoiceHTLC { if x != nil { return x.Htlcs } return nil } func (x *Invoice) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } func (x *Invoice) GetIsKeysend() bool { if x != nil { return x.IsKeysend } return false } func (x *Invoice) GetPaymentAddr() []byte { if x != nil { return x.PaymentAddr } return nil } func (x *Invoice) GetIsAmp() bool { if x != nil { return x.IsAmp } return false } func (x *Invoice) GetAmpInvoiceState() map[string]*AMPInvoiceState { if x != nil { return x.AmpInvoiceState } return nil } // Details of an HTLC that paid to an invoice type InvoiceHTLC struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Short channel id over which the htlc was received. ChanId uint64 `protobuf:"varint,1,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // Index identifying the htlc on the channel. HtlcIndex uint64 `protobuf:"varint,2,opt,name=htlc_index,json=htlcIndex,proto3" json:"htlc_index,omitempty"` // The amount of the htlc in msat. AmtMsat uint64 `protobuf:"varint,3,opt,name=amt_msat,json=amtMsat,proto3" json:"amt_msat,omitempty"` // Block height at which this htlc was accepted. AcceptHeight int32 `protobuf:"varint,4,opt,name=accept_height,json=acceptHeight,proto3" json:"accept_height,omitempty"` // Time at which this htlc was accepted. AcceptTime int64 `protobuf:"varint,5,opt,name=accept_time,json=acceptTime,proto3" json:"accept_time,omitempty"` // Time at which this htlc was settled or canceled. ResolveTime int64 `protobuf:"varint,6,opt,name=resolve_time,json=resolveTime,proto3" json:"resolve_time,omitempty"` // Block height at which this htlc expires. ExpiryHeight int32 `protobuf:"varint,7,opt,name=expiry_height,json=expiryHeight,proto3" json:"expiry_height,omitempty"` // Current state the htlc is in. State InvoiceHTLCState `protobuf:"varint,8,opt,name=state,proto3,enum=lnrpc.InvoiceHTLCState" json:"state,omitempty"` // Custom tlv records. CustomRecords map[uint64][]byte `protobuf:"bytes,9,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // The total amount of the mpp payment in msat. MppTotalAmtMsat uint64 `protobuf:"varint,10,opt,name=mpp_total_amt_msat,json=mppTotalAmtMsat,proto3" json:"mpp_total_amt_msat,omitempty"` // Details relevant to AMP HTLCs, only populated if this is an AMP HTLC. Amp *AMP `protobuf:"bytes,11,opt,name=amp,proto3" json:"amp,omitempty"` } func (x *InvoiceHTLC) Reset() { *x = InvoiceHTLC{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *InvoiceHTLC) String() string { return protoimpl.X.MessageStringOf(x) } func (*InvoiceHTLC) ProtoMessage() {} func (x *InvoiceHTLC) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[122] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use InvoiceHTLC.ProtoReflect.Descriptor instead. func (*InvoiceHTLC) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{122} } func (x *InvoiceHTLC) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *InvoiceHTLC) GetHtlcIndex() uint64 { if x != nil { return x.HtlcIndex } return 0 } func (x *InvoiceHTLC) GetAmtMsat() uint64 { if x != nil { return x.AmtMsat } return 0 } func (x *InvoiceHTLC) GetAcceptHeight() int32 { if x != nil { return x.AcceptHeight } return 0 } func (x *InvoiceHTLC) GetAcceptTime() int64 { if x != nil { return x.AcceptTime } return 0 } func (x *InvoiceHTLC) GetResolveTime() int64 { if x != nil { return x.ResolveTime } return 0 } func (x *InvoiceHTLC) GetExpiryHeight() int32 { if x != nil { return x.ExpiryHeight } return 0 } func (x *InvoiceHTLC) GetState() InvoiceHTLCState { if x != nil { return x.State } return InvoiceHTLCState_ACCEPTED } func (x *InvoiceHTLC) GetCustomRecords() map[uint64][]byte { if x != nil { return x.CustomRecords } return nil } func (x *InvoiceHTLC) GetMppTotalAmtMsat() uint64 { if x != nil { return x.MppTotalAmtMsat } return 0 } func (x *InvoiceHTLC) GetAmp() *AMP { if x != nil { return x.Amp } return nil } // Details specific to AMP HTLCs. type AMP struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // An n-of-n secret share of the root seed from which child payment hashes // and preimages are derived. RootShare []byte `protobuf:"bytes,1,opt,name=root_share,json=rootShare,proto3" json:"root_share,omitempty"` // An identifier for the HTLC set that this HTLC belongs to. SetId []byte `protobuf:"bytes,2,opt,name=set_id,json=setId,proto3" json:"set_id,omitempty"` // A nonce used to randomize the child preimage and child hash from a given // root_share. ChildIndex uint32 `protobuf:"varint,3,opt,name=child_index,json=childIndex,proto3" json:"child_index,omitempty"` // The payment hash of the AMP HTLC. Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` // The preimage used to settle this AMP htlc. This field will only be // populated if the invoice is in InvoiceState_ACCEPTED or // InvoiceState_SETTLED. Preimage []byte `protobuf:"bytes,5,opt,name=preimage,proto3" json:"preimage,omitempty"` } func (x *AMP) Reset() { *x = AMP{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AMP) String() string { return protoimpl.X.MessageStringOf(x) } func (*AMP) ProtoMessage() {} func (x *AMP) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[123] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AMP.ProtoReflect.Descriptor instead. func (*AMP) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{123} } func (x *AMP) GetRootShare() []byte { if x != nil { return x.RootShare } return nil } func (x *AMP) GetSetId() []byte { if x != nil { return x.SetId } return nil } func (x *AMP) GetChildIndex() uint32 { if x != nil { return x.ChildIndex } return 0 } func (x *AMP) GetHash() []byte { if x != nil { return x.Hash } return nil } func (x *AMP) GetPreimage() []byte { if x != nil { return x.Preimage } return nil } type AddInvoiceResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields RHash []byte `protobuf:"bytes,1,opt,name=r_hash,json=rHash,proto3" json:"r_hash,omitempty"` // //A bare-bones invoice for a payment within the Lightning Network. With the //details of the invoice, the sender has all the data necessary to send a //payment to the recipient. PaymentRequest string `protobuf:"bytes,2,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` // //The "add" index of this invoice. Each newly created invoice will increment //this index making it monotonically increasing. Callers to the //SubscribeInvoices call can use this to instantly get notified of all added //invoices with an add_index greater than this one. AddIndex uint64 `protobuf:"varint,16,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` // //The payment address of the generated invoice. This value should be used //in all payments for this invoice as we require it for end to end //security. PaymentAddr []byte `protobuf:"bytes,17,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` } func (x *AddInvoiceResponse) Reset() { *x = AddInvoiceResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AddInvoiceResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*AddInvoiceResponse) ProtoMessage() {} func (x *AddInvoiceResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[124] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AddInvoiceResponse.ProtoReflect.Descriptor instead. func (*AddInvoiceResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{124} } func (x *AddInvoiceResponse) GetRHash() []byte { if x != nil { return x.RHash } return nil } func (x *AddInvoiceResponse) GetPaymentRequest() string { if x != nil { return x.PaymentRequest } return "" } func (x *AddInvoiceResponse) GetAddIndex() uint64 { if x != nil { return x.AddIndex } return 0 } func (x *AddInvoiceResponse) GetPaymentAddr() []byte { if x != nil { return x.PaymentAddr } return nil } type PaymentHash struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The hex-encoded payment hash of the invoice to be looked up. The passed //payment hash must be exactly 32 bytes, otherwise an error is returned. //Deprecated now that the REST gateway supports base64 encoding of bytes //fields. // // Deprecated: Do not use. RHashStr string `protobuf:"bytes,1,opt,name=r_hash_str,json=rHashStr,proto3" json:"r_hash_str,omitempty"` // //The payment hash of the invoice to be looked up. When using REST, this field //must be encoded as base64. RHash []byte `protobuf:"bytes,2,opt,name=r_hash,json=rHash,proto3" json:"r_hash,omitempty"` } func (x *PaymentHash) Reset() { *x = PaymentHash{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PaymentHash) String() string { return protoimpl.X.MessageStringOf(x) } func (*PaymentHash) ProtoMessage() {} func (x *PaymentHash) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[125] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PaymentHash.ProtoReflect.Descriptor instead. func (*PaymentHash) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{125} } // Deprecated: Do not use. func (x *PaymentHash) GetRHashStr() string { if x != nil { return x.RHashStr } return "" } func (x *PaymentHash) GetRHash() []byte { if x != nil { return x.RHash } return nil } type ListInvoiceRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //If set, only invoices that are not settled and not canceled will be returned //in the response. PendingOnly bool `protobuf:"varint,1,opt,name=pending_only,json=pendingOnly,proto3" json:"pending_only,omitempty"` // //The index of an invoice that will be used as either the start or end of a //query to determine which invoices should be returned in the response. IndexOffset uint64 `protobuf:"varint,4,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` // The max number of invoices to return in the response to this query. NumMaxInvoices uint64 `protobuf:"varint,5,opt,name=num_max_invoices,json=numMaxInvoices,proto3" json:"num_max_invoices,omitempty"` // //If set, the invoices returned will result from seeking backwards from the //specified index offset. This can be used to paginate backwards. Reversed bool `protobuf:"varint,6,opt,name=reversed,proto3" json:"reversed,omitempty"` } func (x *ListInvoiceRequest) Reset() { *x = ListInvoiceRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListInvoiceRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListInvoiceRequest) ProtoMessage() {} func (x *ListInvoiceRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[126] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListInvoiceRequest.ProtoReflect.Descriptor instead. func (*ListInvoiceRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{126} } func (x *ListInvoiceRequest) GetPendingOnly() bool { if x != nil { return x.PendingOnly } return false } func (x *ListInvoiceRequest) GetIndexOffset() uint64 { if x != nil { return x.IndexOffset } return 0 } func (x *ListInvoiceRequest) GetNumMaxInvoices() uint64 { if x != nil { return x.NumMaxInvoices } return 0 } func (x *ListInvoiceRequest) GetReversed() bool { if x != nil { return x.Reversed } return false } type ListInvoiceResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A list of invoices from the time slice of the time series specified in the //request. Invoices []*Invoice `protobuf:"bytes,1,rep,name=invoices,proto3" json:"invoices,omitempty"` // //The index of the last item in the set of returned invoices. This can be used //to seek further, pagination style. LastIndexOffset uint64 `protobuf:"varint,2,opt,name=last_index_offset,json=lastIndexOffset,proto3" json:"last_index_offset,omitempty"` // //The index of the last item in the set of returned invoices. This can be used //to seek backwards, pagination style. FirstIndexOffset uint64 `protobuf:"varint,3,opt,name=first_index_offset,json=firstIndexOffset,proto3" json:"first_index_offset,omitempty"` } func (x *ListInvoiceResponse) Reset() { *x = ListInvoiceResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListInvoiceResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListInvoiceResponse) ProtoMessage() {} func (x *ListInvoiceResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[127] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListInvoiceResponse.ProtoReflect.Descriptor instead. func (*ListInvoiceResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{127} } func (x *ListInvoiceResponse) GetInvoices() []*Invoice { if x != nil { return x.Invoices } return nil } func (x *ListInvoiceResponse) GetLastIndexOffset() uint64 { if x != nil { return x.LastIndexOffset } return 0 } func (x *ListInvoiceResponse) GetFirstIndexOffset() uint64 { if x != nil { return x.FirstIndexOffset } return 0 } type InvoiceSubscription struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //If specified (non-zero), then we'll first start by sending out //notifications for all added indexes with an add_index greater than this //value. This allows callers to catch up on any events they missed while they //weren't connected to the streaming RPC. AddIndex uint64 `protobuf:"varint,1,opt,name=add_index,json=addIndex,proto3" json:"add_index,omitempty"` // //If specified (non-zero), then we'll first start by sending out //notifications for all settled indexes with an settle_index greater than //this value. This allows callers to catch up on any events they missed while //they weren't connected to the streaming RPC. SettleIndex uint64 `protobuf:"varint,2,opt,name=settle_index,json=settleIndex,proto3" json:"settle_index,omitempty"` } func (x *InvoiceSubscription) Reset() { *x = InvoiceSubscription{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *InvoiceSubscription) String() string { return protoimpl.X.MessageStringOf(x) } func (*InvoiceSubscription) ProtoMessage() {} func (x *InvoiceSubscription) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[128] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use InvoiceSubscription.ProtoReflect.Descriptor instead. func (*InvoiceSubscription) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{128} } func (x *InvoiceSubscription) GetAddIndex() uint64 { if x != nil { return x.AddIndex } return 0 } func (x *InvoiceSubscription) GetSettleIndex() uint64 { if x != nil { return x.SettleIndex } return 0 } type Payment struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The payment hash PaymentHash string `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` // Deprecated, use value_sat or value_msat. // // Deprecated: Do not use. Value int64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` // Deprecated, use creation_time_ns // // Deprecated: Do not use. CreationDate int64 `protobuf:"varint,3,opt,name=creation_date,json=creationDate,proto3" json:"creation_date,omitempty"` // Deprecated, use fee_sat or fee_msat. // // Deprecated: Do not use. Fee int64 `protobuf:"varint,5,opt,name=fee,proto3" json:"fee,omitempty"` // The payment preimage PaymentPreimage string `protobuf:"bytes,6,opt,name=payment_preimage,json=paymentPreimage,proto3" json:"payment_preimage,omitempty"` // The value of the payment in satoshis ValueSat int64 `protobuf:"varint,7,opt,name=value_sat,json=valueSat,proto3" json:"value_sat,omitempty"` // The value of the payment in milli-satoshis ValueMsat int64 `protobuf:"varint,8,opt,name=value_msat,json=valueMsat,proto3" json:"value_msat,omitempty"` // The optional payment request being fulfilled. PaymentRequest string `protobuf:"bytes,9,opt,name=payment_request,json=paymentRequest,proto3" json:"payment_request,omitempty"` // The status of the payment. Status Payment_PaymentStatus `protobuf:"varint,10,opt,name=status,proto3,enum=lnrpc.Payment_PaymentStatus" json:"status,omitempty"` // The fee paid for this payment in satoshis FeeSat int64 `protobuf:"varint,11,opt,name=fee_sat,json=feeSat,proto3" json:"fee_sat,omitempty"` // The fee paid for this payment in milli-satoshis FeeMsat int64 `protobuf:"varint,12,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` // The time in UNIX nanoseconds at which the payment was created. CreationTimeNs int64 `protobuf:"varint,13,opt,name=creation_time_ns,json=creationTimeNs,proto3" json:"creation_time_ns,omitempty"` // The HTLCs made in attempt to settle the payment. Htlcs []*HTLCAttempt `protobuf:"bytes,14,rep,name=htlcs,proto3" json:"htlcs,omitempty"` // //The creation index of this payment. Each payment can be uniquely identified //by this index, which may not strictly increment by 1 for payments made in //older versions of lnd. PaymentIndex uint64 `protobuf:"varint,15,opt,name=payment_index,json=paymentIndex,proto3" json:"payment_index,omitempty"` FailureReason PaymentFailureReason `protobuf:"varint,16,opt,name=failure_reason,json=failureReason,proto3,enum=lnrpc.PaymentFailureReason" json:"failure_reason,omitempty"` } func (x *Payment) Reset() { *x = Payment{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Payment) String() string { return protoimpl.X.MessageStringOf(x) } func (*Payment) ProtoMessage() {} func (x *Payment) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[129] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Payment.ProtoReflect.Descriptor instead. func (*Payment) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{129} } func (x *Payment) GetPaymentHash() string { if x != nil { return x.PaymentHash } return "" } // Deprecated: Do not use. func (x *Payment) GetValue() int64 { if x != nil { return x.Value } return 0 } // Deprecated: Do not use. func (x *Payment) GetCreationDate() int64 { if x != nil { return x.CreationDate } return 0 } // Deprecated: Do not use. func (x *Payment) GetFee() int64 { if x != nil { return x.Fee } return 0 } func (x *Payment) GetPaymentPreimage() string { if x != nil { return x.PaymentPreimage } return "" } func (x *Payment) GetValueSat() int64 { if x != nil { return x.ValueSat } return 0 } func (x *Payment) GetValueMsat() int64 { if x != nil { return x.ValueMsat } return 0 } func (x *Payment) GetPaymentRequest() string { if x != nil { return x.PaymentRequest } return "" } func (x *Payment) GetStatus() Payment_PaymentStatus { if x != nil { return x.Status } return Payment_UNKNOWN } func (x *Payment) GetFeeSat() int64 { if x != nil { return x.FeeSat } return 0 } func (x *Payment) GetFeeMsat() int64 { if x != nil { return x.FeeMsat } return 0 } func (x *Payment) GetCreationTimeNs() int64 { if x != nil { return x.CreationTimeNs } return 0 } func (x *Payment) GetHtlcs() []*HTLCAttempt { if x != nil { return x.Htlcs } return nil } func (x *Payment) GetPaymentIndex() uint64 { if x != nil { return x.PaymentIndex } return 0 } func (x *Payment) GetFailureReason() PaymentFailureReason { if x != nil { return x.FailureReason } return PaymentFailureReason_FAILURE_REASON_NONE } type HTLCAttempt struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The unique ID that is used for this attempt. AttemptId uint64 `protobuf:"varint,7,opt,name=attempt_id,json=attemptId,proto3" json:"attempt_id,omitempty"` // The status of the HTLC. Status HTLCAttempt_HTLCStatus `protobuf:"varint,1,opt,name=status,proto3,enum=lnrpc.HTLCAttempt_HTLCStatus" json:"status,omitempty"` // The route taken by this HTLC. Route *Route `protobuf:"bytes,2,opt,name=route,proto3" json:"route,omitempty"` // The time in UNIX nanoseconds at which this HTLC was sent. AttemptTimeNs int64 `protobuf:"varint,3,opt,name=attempt_time_ns,json=attemptTimeNs,proto3" json:"attempt_time_ns,omitempty"` // //The time in UNIX nanoseconds at which this HTLC was settled or failed. //This value will not be set if the HTLC is still IN_FLIGHT. ResolveTimeNs int64 `protobuf:"varint,4,opt,name=resolve_time_ns,json=resolveTimeNs,proto3" json:"resolve_time_ns,omitempty"` // Detailed htlc failure info. Failure *Failure `protobuf:"bytes,5,opt,name=failure,proto3" json:"failure,omitempty"` // The preimage that was used to settle the HTLC. Preimage []byte `protobuf:"bytes,6,opt,name=preimage,proto3" json:"preimage,omitempty"` } func (x *HTLCAttempt) Reset() { *x = HTLCAttempt{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *HTLCAttempt) String() string { return protoimpl.X.MessageStringOf(x) } func (*HTLCAttempt) ProtoMessage() {} func (x *HTLCAttempt) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[130] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use HTLCAttempt.ProtoReflect.Descriptor instead. func (*HTLCAttempt) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{130} } func (x *HTLCAttempt) GetAttemptId() uint64 { if x != nil { return x.AttemptId } return 0 } func (x *HTLCAttempt) GetStatus() HTLCAttempt_HTLCStatus { if x != nil { return x.Status } return HTLCAttempt_IN_FLIGHT } func (x *HTLCAttempt) GetRoute() *Route { if x != nil { return x.Route } return nil } func (x *HTLCAttempt) GetAttemptTimeNs() int64 { if x != nil { return x.AttemptTimeNs } return 0 } func (x *HTLCAttempt) GetResolveTimeNs() int64 { if x != nil { return x.ResolveTimeNs } return 0 } func (x *HTLCAttempt) GetFailure() *Failure { if x != nil { return x.Failure } return nil } func (x *HTLCAttempt) GetPreimage() []byte { if x != nil { return x.Preimage } return nil } type ListPaymentsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //If true, then return payments that have not yet fully completed. This means //that pending payments, as well as failed payments will show up if this //field is set to true. This flag doesn't change the meaning of the indices, //which are tied to individual payments. IncludeIncomplete bool `protobuf:"varint,1,opt,name=include_incomplete,json=includeIncomplete,proto3" json:"include_incomplete,omitempty"` // //The index of a payment that will be used as either the start or end of a //query to determine which payments should be returned in the response. The //index_offset is exclusive. In the case of a zero index_offset, the query //will start with the oldest payment when paginating forwards, or will end //with the most recent payment when paginating backwards. IndexOffset uint64 `protobuf:"varint,2,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` // The maximal number of payments returned in the response to this query. MaxPayments uint64 `protobuf:"varint,3,opt,name=max_payments,json=maxPayments,proto3" json:"max_payments,omitempty"` // //If set, the payments returned will result from seeking backwards from the //specified index offset. This can be used to paginate backwards. The order //of the returned payments is always oldest first (ascending index order). Reversed bool `protobuf:"varint,4,opt,name=reversed,proto3" json:"reversed,omitempty"` } func (x *ListPaymentsRequest) Reset() { *x = ListPaymentsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPaymentsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPaymentsRequest) ProtoMessage() {} func (x *ListPaymentsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[131] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPaymentsRequest.ProtoReflect.Descriptor instead. func (*ListPaymentsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{131} } func (x *ListPaymentsRequest) GetIncludeIncomplete() bool { if x != nil { return x.IncludeIncomplete } return false } func (x *ListPaymentsRequest) GetIndexOffset() uint64 { if x != nil { return x.IndexOffset } return 0 } func (x *ListPaymentsRequest) GetMaxPayments() uint64 { if x != nil { return x.MaxPayments } return 0 } func (x *ListPaymentsRequest) GetReversed() bool { if x != nil { return x.Reversed } return false } type ListPaymentsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of payments Payments []*Payment `protobuf:"bytes,1,rep,name=payments,proto3" json:"payments,omitempty"` // //The index of the first item in the set of returned payments. This can be //used as the index_offset to continue seeking backwards in the next request. FirstIndexOffset uint64 `protobuf:"varint,2,opt,name=first_index_offset,json=firstIndexOffset,proto3" json:"first_index_offset,omitempty"` // //The index of the last item in the set of returned payments. This can be used //as the index_offset to continue seeking forwards in the next request. LastIndexOffset uint64 `protobuf:"varint,3,opt,name=last_index_offset,json=lastIndexOffset,proto3" json:"last_index_offset,omitempty"` } func (x *ListPaymentsResponse) Reset() { *x = ListPaymentsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPaymentsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPaymentsResponse) ProtoMessage() {} func (x *ListPaymentsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[132] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPaymentsResponse.ProtoReflect.Descriptor instead. func (*ListPaymentsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{132} } func (x *ListPaymentsResponse) GetPayments() []*Payment { if x != nil { return x.Payments } return nil } func (x *ListPaymentsResponse) GetFirstIndexOffset() uint64 { if x != nil { return x.FirstIndexOffset } return 0 } func (x *ListPaymentsResponse) GetLastIndexOffset() uint64 { if x != nil { return x.LastIndexOffset } return 0 } type DeletePaymentRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Payment hash to delete. PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` // //Only delete failed HTLCs from the payment, not the payment itself. FailedHtlcsOnly bool `protobuf:"varint,2,opt,name=failed_htlcs_only,json=failedHtlcsOnly,proto3" json:"failed_htlcs_only,omitempty"` } func (x *DeletePaymentRequest) Reset() { *x = DeletePaymentRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[133] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeletePaymentRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeletePaymentRequest) ProtoMessage() {} func (x *DeletePaymentRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[133] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeletePaymentRequest.ProtoReflect.Descriptor instead. func (*DeletePaymentRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{133} } func (x *DeletePaymentRequest) GetPaymentHash() []byte { if x != nil { return x.PaymentHash } return nil } func (x *DeletePaymentRequest) GetFailedHtlcsOnly() bool { if x != nil { return x.FailedHtlcsOnly } return false } type DeleteAllPaymentsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Only delete failed payments. FailedPaymentsOnly bool `protobuf:"varint,1,opt,name=failed_payments_only,json=failedPaymentsOnly,proto3" json:"failed_payments_only,omitempty"` // //Only delete failed HTLCs from payments, not the payment itself. FailedHtlcsOnly bool `protobuf:"varint,2,opt,name=failed_htlcs_only,json=failedHtlcsOnly,proto3" json:"failed_htlcs_only,omitempty"` } func (x *DeleteAllPaymentsRequest) Reset() { *x = DeleteAllPaymentsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[134] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeleteAllPaymentsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeleteAllPaymentsRequest) ProtoMessage() {} func (x *DeleteAllPaymentsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[134] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeleteAllPaymentsRequest.ProtoReflect.Descriptor instead. func (*DeleteAllPaymentsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{134} } func (x *DeleteAllPaymentsRequest) GetFailedPaymentsOnly() bool { if x != nil { return x.FailedPaymentsOnly } return false } func (x *DeleteAllPaymentsRequest) GetFailedHtlcsOnly() bool { if x != nil { return x.FailedHtlcsOnly } return false } type DeletePaymentResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *DeletePaymentResponse) Reset() { *x = DeletePaymentResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[135] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeletePaymentResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeletePaymentResponse) ProtoMessage() {} func (x *DeletePaymentResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[135] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeletePaymentResponse.ProtoReflect.Descriptor instead. func (*DeletePaymentResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{135} } type DeleteAllPaymentsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *DeleteAllPaymentsResponse) Reset() { *x = DeleteAllPaymentsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[136] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeleteAllPaymentsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeleteAllPaymentsResponse) ProtoMessage() {} func (x *DeleteAllPaymentsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[136] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeleteAllPaymentsResponse.ProtoReflect.Descriptor instead. func (*DeleteAllPaymentsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{136} } type AbandonChannelRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields ChannelPoint *ChannelPoint `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` PendingFundingShimOnly bool `protobuf:"varint,2,opt,name=pending_funding_shim_only,json=pendingFundingShimOnly,proto3" json:"pending_funding_shim_only,omitempty"` // //Override the requirement for being in dev mode by setting this to true and //confirming the user knows what they are doing and this is a potential foot //gun to lose funds if used on active channels. IKnowWhatIAmDoing bool `protobuf:"varint,3,opt,name=i_know_what_i_am_doing,json=iKnowWhatIAmDoing,proto3" json:"i_know_what_i_am_doing,omitempty"` } func (x *AbandonChannelRequest) Reset() { *x = AbandonChannelRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[137] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AbandonChannelRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*AbandonChannelRequest) ProtoMessage() {} func (x *AbandonChannelRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[137] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AbandonChannelRequest.ProtoReflect.Descriptor instead. func (*AbandonChannelRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{137} } func (x *AbandonChannelRequest) GetChannelPoint() *ChannelPoint { if x != nil { return x.ChannelPoint } return nil } func (x *AbandonChannelRequest) GetPendingFundingShimOnly() bool { if x != nil { return x.PendingFundingShimOnly } return false } func (x *AbandonChannelRequest) GetIKnowWhatIAmDoing() bool { if x != nil { return x.IKnowWhatIAmDoing } return false } type AbandonChannelResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *AbandonChannelResponse) Reset() { *x = AbandonChannelResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[138] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *AbandonChannelResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*AbandonChannelResponse) ProtoMessage() {} func (x *AbandonChannelResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[138] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use AbandonChannelResponse.ProtoReflect.Descriptor instead. func (*AbandonChannelResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{138} } type DebugLevelRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Show bool `protobuf:"varint,1,opt,name=show,proto3" json:"show,omitempty"` LevelSpec string `protobuf:"bytes,2,opt,name=level_spec,json=levelSpec,proto3" json:"level_spec,omitempty"` } func (x *DebugLevelRequest) Reset() { *x = DebugLevelRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[139] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DebugLevelRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*DebugLevelRequest) ProtoMessage() {} func (x *DebugLevelRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[139] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DebugLevelRequest.ProtoReflect.Descriptor instead. func (*DebugLevelRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{139} } func (x *DebugLevelRequest) GetShow() bool { if x != nil { return x.Show } return false } func (x *DebugLevelRequest) GetLevelSpec() string { if x != nil { return x.LevelSpec } return "" } type DebugLevelResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields SubSystems string `protobuf:"bytes,1,opt,name=sub_systems,json=subSystems,proto3" json:"sub_systems,omitempty"` } func (x *DebugLevelResponse) Reset() { *x = DebugLevelResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[140] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DebugLevelResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*DebugLevelResponse) ProtoMessage() {} func (x *DebugLevelResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[140] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DebugLevelResponse.ProtoReflect.Descriptor instead. func (*DebugLevelResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{140} } func (x *DebugLevelResponse) GetSubSystems() string { if x != nil { return x.SubSystems } return "" } type PayReqString struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The payment request string to be decoded PayReq string `protobuf:"bytes,1,opt,name=pay_req,json=payReq,proto3" json:"pay_req,omitempty"` } func (x *PayReqString) Reset() { *x = PayReqString{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[141] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PayReqString) String() string { return protoimpl.X.MessageStringOf(x) } func (*PayReqString) ProtoMessage() {} func (x *PayReqString) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[141] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PayReqString.ProtoReflect.Descriptor instead. func (*PayReqString) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{141} } func (x *PayReqString) GetPayReq() string { if x != nil { return x.PayReq } return "" } type PayReq struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Destination string `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"` PaymentHash string `protobuf:"bytes,2,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` NumSatoshis int64 `protobuf:"varint,3,opt,name=num_satoshis,json=numSatoshis,proto3" json:"num_satoshis,omitempty"` Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` Expiry int64 `protobuf:"varint,5,opt,name=expiry,proto3" json:"expiry,omitempty"` Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"` DescriptionHash string `protobuf:"bytes,7,opt,name=description_hash,json=descriptionHash,proto3" json:"description_hash,omitempty"` FallbackAddr string `protobuf:"bytes,8,opt,name=fallback_addr,json=fallbackAddr,proto3" json:"fallback_addr,omitempty"` CltvExpiry int64 `protobuf:"varint,9,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` RouteHints []*RouteHint `protobuf:"bytes,10,rep,name=route_hints,json=routeHints,proto3" json:"route_hints,omitempty"` PaymentAddr []byte `protobuf:"bytes,11,opt,name=payment_addr,json=paymentAddr,proto3" json:"payment_addr,omitempty"` NumMsat int64 `protobuf:"varint,12,opt,name=num_msat,json=numMsat,proto3" json:"num_msat,omitempty"` Features map[uint32]*Feature `protobuf:"bytes,13,rep,name=features,proto3" json:"features,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *PayReq) Reset() { *x = PayReq{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[142] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PayReq) String() string { return protoimpl.X.MessageStringOf(x) } func (*PayReq) ProtoMessage() {} func (x *PayReq) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[142] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PayReq.ProtoReflect.Descriptor instead. func (*PayReq) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{142} } func (x *PayReq) GetDestination() string { if x != nil { return x.Destination } return "" } func (x *PayReq) GetPaymentHash() string { if x != nil { return x.PaymentHash } return "" } func (x *PayReq) GetNumSatoshis() int64 { if x != nil { return x.NumSatoshis } return 0 } func (x *PayReq) GetTimestamp() int64 { if x != nil { return x.Timestamp } return 0 } func (x *PayReq) GetExpiry() int64 { if x != nil { return x.Expiry } return 0 } func (x *PayReq) GetDescription() string { if x != nil { return x.Description } return "" } func (x *PayReq) GetDescriptionHash() string { if x != nil { return x.DescriptionHash } return "" } func (x *PayReq) GetFallbackAddr() string { if x != nil { return x.FallbackAddr } return "" } func (x *PayReq) GetCltvExpiry() int64 { if x != nil { return x.CltvExpiry } return 0 } func (x *PayReq) GetRouteHints() []*RouteHint { if x != nil { return x.RouteHints } return nil } func (x *PayReq) GetPaymentAddr() []byte { if x != nil { return x.PaymentAddr } return nil } func (x *PayReq) GetNumMsat() int64 { if x != nil { return x.NumMsat } return 0 } func (x *PayReq) GetFeatures() map[uint32]*Feature { if x != nil { return x.Features } return nil } type Feature struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` IsRequired bool `protobuf:"varint,3,opt,name=is_required,json=isRequired,proto3" json:"is_required,omitempty"` IsKnown bool `protobuf:"varint,4,opt,name=is_known,json=isKnown,proto3" json:"is_known,omitempty"` } func (x *Feature) Reset() { *x = Feature{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[143] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Feature) String() string { return protoimpl.X.MessageStringOf(x) } func (*Feature) ProtoMessage() {} func (x *Feature) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[143] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Feature.ProtoReflect.Descriptor instead. func (*Feature) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{143} } func (x *Feature) GetName() string { if x != nil { return x.Name } return "" } func (x *Feature) GetIsRequired() bool { if x != nil { return x.IsRequired } return false } func (x *Feature) GetIsKnown() bool { if x != nil { return x.IsKnown } return false } type FeeReportRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *FeeReportRequest) Reset() { *x = FeeReportRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[144] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FeeReportRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*FeeReportRequest) ProtoMessage() {} func (x *FeeReportRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[144] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FeeReportRequest.ProtoReflect.Descriptor instead. func (*FeeReportRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{144} } type ChannelFeeReport struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The short channel id that this fee report belongs to. ChanId uint64 `protobuf:"varint,5,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // The channel that this fee report belongs to. ChannelPoint string `protobuf:"bytes,1,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` // The base fee charged regardless of the number of milli-satoshis sent. BaseFeeMsat int64 `protobuf:"varint,2,opt,name=base_fee_msat,json=baseFeeMsat,proto3" json:"base_fee_msat,omitempty"` // The amount charged per milli-satoshis transferred expressed in // millionths of a satoshi. FeePerMil int64 `protobuf:"varint,3,opt,name=fee_per_mil,json=feePerMil,proto3" json:"fee_per_mil,omitempty"` // The effective fee rate in milli-satoshis. Computed by dividing the // fee_per_mil value by 1 million. FeeRate float64 `protobuf:"fixed64,4,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` } func (x *ChannelFeeReport) Reset() { *x = ChannelFeeReport{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[145] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelFeeReport) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelFeeReport) ProtoMessage() {} func (x *ChannelFeeReport) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[145] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelFeeReport.ProtoReflect.Descriptor instead. func (*ChannelFeeReport) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{145} } func (x *ChannelFeeReport) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *ChannelFeeReport) GetChannelPoint() string { if x != nil { return x.ChannelPoint } return "" } func (x *ChannelFeeReport) GetBaseFeeMsat() int64 { if x != nil { return x.BaseFeeMsat } return 0 } func (x *ChannelFeeReport) GetFeePerMil() int64 { if x != nil { return x.FeePerMil } return 0 } func (x *ChannelFeeReport) GetFeeRate() float64 { if x != nil { return x.FeeRate } return 0 } type FeeReportResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // An array of channel fee reports which describes the current fee schedule // for each channel. ChannelFees []*ChannelFeeReport `protobuf:"bytes,1,rep,name=channel_fees,json=channelFees,proto3" json:"channel_fees,omitempty"` // The total amount of fee revenue (in satoshis) the switch has collected // over the past 24 hrs. DayFeeSum uint64 `protobuf:"varint,2,opt,name=day_fee_sum,json=dayFeeSum,proto3" json:"day_fee_sum,omitempty"` // The total amount of fee revenue (in satoshis) the switch has collected // over the past 1 week. WeekFeeSum uint64 `protobuf:"varint,3,opt,name=week_fee_sum,json=weekFeeSum,proto3" json:"week_fee_sum,omitempty"` // The total amount of fee revenue (in satoshis) the switch has collected // over the past 1 month. MonthFeeSum uint64 `protobuf:"varint,4,opt,name=month_fee_sum,json=monthFeeSum,proto3" json:"month_fee_sum,omitempty"` } func (x *FeeReportResponse) Reset() { *x = FeeReportResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[146] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FeeReportResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*FeeReportResponse) ProtoMessage() {} func (x *FeeReportResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[146] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FeeReportResponse.ProtoReflect.Descriptor instead. func (*FeeReportResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{146} } func (x *FeeReportResponse) GetChannelFees() []*ChannelFeeReport { if x != nil { return x.ChannelFees } return nil } func (x *FeeReportResponse) GetDayFeeSum() uint64 { if x != nil { return x.DayFeeSum } return 0 } func (x *FeeReportResponse) GetWeekFeeSum() uint64 { if x != nil { return x.WeekFeeSum } return 0 } func (x *FeeReportResponse) GetMonthFeeSum() uint64 { if x != nil { return x.MonthFeeSum } return 0 } type PolicyUpdateRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Scope: // *PolicyUpdateRequest_Global // *PolicyUpdateRequest_ChanPoint Scope isPolicyUpdateRequest_Scope `protobuf_oneof:"scope"` // The base fee charged regardless of the number of milli-satoshis sent. BaseFeeMsat int64 `protobuf:"varint,3,opt,name=base_fee_msat,json=baseFeeMsat,proto3" json:"base_fee_msat,omitempty"` // The effective fee rate in milli-satoshis. The precision of this value // goes up to 6 decimal places, so 1e-6. FeeRate float64 `protobuf:"fixed64,4,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` // The required timelock delta for HTLCs forwarded over the channel. TimeLockDelta uint32 `protobuf:"varint,5,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` // If set, the maximum HTLC size in milli-satoshis. If unset, the maximum // HTLC will be unchanged. MaxHtlcMsat uint64 `protobuf:"varint,6,opt,name=max_htlc_msat,json=maxHtlcMsat,proto3" json:"max_htlc_msat,omitempty"` // The minimum HTLC size in milli-satoshis. Only applied if // min_htlc_msat_specified is true. MinHtlcMsat uint64 `protobuf:"varint,7,opt,name=min_htlc_msat,json=minHtlcMsat,proto3" json:"min_htlc_msat,omitempty"` // If true, min_htlc_msat is applied. MinHtlcMsatSpecified bool `protobuf:"varint,8,opt,name=min_htlc_msat_specified,json=minHtlcMsatSpecified,proto3" json:"min_htlc_msat_specified,omitempty"` } func (x *PolicyUpdateRequest) Reset() { *x = PolicyUpdateRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[147] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PolicyUpdateRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*PolicyUpdateRequest) ProtoMessage() {} func (x *PolicyUpdateRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[147] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PolicyUpdateRequest.ProtoReflect.Descriptor instead. func (*PolicyUpdateRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{147} } func (m *PolicyUpdateRequest) GetScope() isPolicyUpdateRequest_Scope { if m != nil { return m.Scope } return nil } func (x *PolicyUpdateRequest) GetGlobal() bool { if x, ok := x.GetScope().(*PolicyUpdateRequest_Global); ok { return x.Global } return false } func (x *PolicyUpdateRequest) GetChanPoint() *ChannelPoint { if x, ok := x.GetScope().(*PolicyUpdateRequest_ChanPoint); ok { return x.ChanPoint } return nil } func (x *PolicyUpdateRequest) GetBaseFeeMsat() int64 { if x != nil { return x.BaseFeeMsat } return 0 } func (x *PolicyUpdateRequest) GetFeeRate() float64 { if x != nil { return x.FeeRate } return 0 } func (x *PolicyUpdateRequest) GetTimeLockDelta() uint32 { if x != nil { return x.TimeLockDelta } return 0 } func (x *PolicyUpdateRequest) GetMaxHtlcMsat() uint64 { if x != nil { return x.MaxHtlcMsat } return 0 } func (x *PolicyUpdateRequest) GetMinHtlcMsat() uint64 { if x != nil { return x.MinHtlcMsat } return 0 } func (x *PolicyUpdateRequest) GetMinHtlcMsatSpecified() bool { if x != nil { return x.MinHtlcMsatSpecified } return false } type isPolicyUpdateRequest_Scope interface { isPolicyUpdateRequest_Scope() } type PolicyUpdateRequest_Global struct { // If set, then this update applies to all currently active channels. Global bool `protobuf:"varint,1,opt,name=global,proto3,oneof"` } type PolicyUpdateRequest_ChanPoint struct { // If set, this update will target a specific channel. ChanPoint *ChannelPoint `protobuf:"bytes,2,opt,name=chan_point,json=chanPoint,proto3,oneof"` } func (*PolicyUpdateRequest_Global) isPolicyUpdateRequest_Scope() {} func (*PolicyUpdateRequest_ChanPoint) isPolicyUpdateRequest_Scope() {} type FailedUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The outpoint in format txid:n Outpoint *OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // Reason for the policy update failure. Reason UpdateFailure `protobuf:"varint,2,opt,name=reason,proto3,enum=lnrpc.UpdateFailure" json:"reason,omitempty"` // A string representation of the policy update error. UpdateError string `protobuf:"bytes,3,opt,name=update_error,json=updateError,proto3" json:"update_error,omitempty"` } func (x *FailedUpdate) Reset() { *x = FailedUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[148] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *FailedUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*FailedUpdate) ProtoMessage() {} func (x *FailedUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[148] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use FailedUpdate.ProtoReflect.Descriptor instead. func (*FailedUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{148} } func (x *FailedUpdate) GetOutpoint() *OutPoint { if x != nil { return x.Outpoint } return nil } func (x *FailedUpdate) GetReason() UpdateFailure { if x != nil { return x.Reason } return UpdateFailure_UPDATE_FAILURE_UNKNOWN } func (x *FailedUpdate) GetUpdateError() string { if x != nil { return x.UpdateError } return "" } type PolicyUpdateResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // List of failed policy updates. FailedUpdates []*FailedUpdate `protobuf:"bytes,1,rep,name=failed_updates,json=failedUpdates,proto3" json:"failed_updates,omitempty"` } func (x *PolicyUpdateResponse) Reset() { *x = PolicyUpdateResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[149] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PolicyUpdateResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*PolicyUpdateResponse) ProtoMessage() {} func (x *PolicyUpdateResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[149] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PolicyUpdateResponse.ProtoReflect.Descriptor instead. func (*PolicyUpdateResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{149} } func (x *PolicyUpdateResponse) GetFailedUpdates() []*FailedUpdate { if x != nil { return x.FailedUpdates } return nil } type ForwardingHistoryRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Start time is the starting point of the forwarding history request. All // records beyond this point will be included, respecting the end time, and // the index offset. StartTime uint64 `protobuf:"varint,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` // End time is the end point of the forwarding history request. The // response will carry at most 50k records between the start time and the // end time. The index offset can be used to implement pagination. EndTime uint64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` // Index offset is the offset in the time series to start at. As each // response can only contain 50k records, callers can use this to skip // around within a packed time series. IndexOffset uint32 `protobuf:"varint,3,opt,name=index_offset,json=indexOffset,proto3" json:"index_offset,omitempty"` // The max number of events to return in the response to this query. NumMaxEvents uint32 `protobuf:"varint,4,opt,name=num_max_events,json=numMaxEvents,proto3" json:"num_max_events,omitempty"` } func (x *ForwardingHistoryRequest) Reset() { *x = ForwardingHistoryRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[150] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ForwardingHistoryRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ForwardingHistoryRequest) ProtoMessage() {} func (x *ForwardingHistoryRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[150] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ForwardingHistoryRequest.ProtoReflect.Descriptor instead. func (*ForwardingHistoryRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{150} } func (x *ForwardingHistoryRequest) GetStartTime() uint64 { if x != nil { return x.StartTime } return 0 } func (x *ForwardingHistoryRequest) GetEndTime() uint64 { if x != nil { return x.EndTime } return 0 } func (x *ForwardingHistoryRequest) GetIndexOffset() uint32 { if x != nil { return x.IndexOffset } return 0 } func (x *ForwardingHistoryRequest) GetNumMaxEvents() uint32 { if x != nil { return x.NumMaxEvents } return 0 } type ForwardingEvent struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Timestamp is the time (unix epoch offset) that this circuit was // completed. Deprecated by timestamp_ns. // // Deprecated: Do not use. Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The incoming channel ID that carried the HTLC that created the circuit. ChanIdIn uint64 `protobuf:"varint,2,opt,name=chan_id_in,json=chanIdIn,proto3" json:"chan_id_in,omitempty"` // The outgoing channel ID that carried the preimage that completed the // circuit. ChanIdOut uint64 `protobuf:"varint,4,opt,name=chan_id_out,json=chanIdOut,proto3" json:"chan_id_out,omitempty"` // The total amount (in satoshis) of the incoming HTLC that created half // the circuit. AmtIn uint64 `protobuf:"varint,5,opt,name=amt_in,json=amtIn,proto3" json:"amt_in,omitempty"` // The total amount (in satoshis) of the outgoing HTLC that created the // second half of the circuit. AmtOut uint64 `protobuf:"varint,6,opt,name=amt_out,json=amtOut,proto3" json:"amt_out,omitempty"` // The total fee (in satoshis) that this payment circuit carried. Fee uint64 `protobuf:"varint,7,opt,name=fee,proto3" json:"fee,omitempty"` // The total fee (in milli-satoshis) that this payment circuit carried. FeeMsat uint64 `protobuf:"varint,8,opt,name=fee_msat,json=feeMsat,proto3" json:"fee_msat,omitempty"` // The total amount (in milli-satoshis) of the incoming HTLC that created // half the circuit. AmtInMsat uint64 `protobuf:"varint,9,opt,name=amt_in_msat,json=amtInMsat,proto3" json:"amt_in_msat,omitempty"` // The total amount (in milli-satoshis) of the outgoing HTLC that created // the second half of the circuit. AmtOutMsat uint64 `protobuf:"varint,10,opt,name=amt_out_msat,json=amtOutMsat,proto3" json:"amt_out_msat,omitempty"` // The number of nanoseconds elapsed since January 1, 1970 UTC when this // circuit was completed. TimestampNs uint64 `protobuf:"varint,11,opt,name=timestamp_ns,json=timestampNs,proto3" json:"timestamp_ns,omitempty"` } func (x *ForwardingEvent) Reset() { *x = ForwardingEvent{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[151] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ForwardingEvent) String() string { return protoimpl.X.MessageStringOf(x) } func (*ForwardingEvent) ProtoMessage() {} func (x *ForwardingEvent) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[151] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ForwardingEvent.ProtoReflect.Descriptor instead. func (*ForwardingEvent) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{151} } // Deprecated: Do not use. func (x *ForwardingEvent) GetTimestamp() uint64 { if x != nil { return x.Timestamp } return 0 } func (x *ForwardingEvent) GetChanIdIn() uint64 { if x != nil { return x.ChanIdIn } return 0 } func (x *ForwardingEvent) GetChanIdOut() uint64 { if x != nil { return x.ChanIdOut } return 0 } func (x *ForwardingEvent) GetAmtIn() uint64 { if x != nil { return x.AmtIn } return 0 } func (x *ForwardingEvent) GetAmtOut() uint64 { if x != nil { return x.AmtOut } return 0 } func (x *ForwardingEvent) GetFee() uint64 { if x != nil { return x.Fee } return 0 } func (x *ForwardingEvent) GetFeeMsat() uint64 { if x != nil { return x.FeeMsat } return 0 } func (x *ForwardingEvent) GetAmtInMsat() uint64 { if x != nil { return x.AmtInMsat } return 0 } func (x *ForwardingEvent) GetAmtOutMsat() uint64 { if x != nil { return x.AmtOutMsat } return 0 } func (x *ForwardingEvent) GetTimestampNs() uint64 { if x != nil { return x.TimestampNs } return 0 } type ForwardingHistoryResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // A list of forwarding events from the time slice of the time series // specified in the request. ForwardingEvents []*ForwardingEvent `protobuf:"bytes,1,rep,name=forwarding_events,json=forwardingEvents,proto3" json:"forwarding_events,omitempty"` // The index of the last time in the set of returned forwarding events. Can // be used to seek further, pagination style. LastOffsetIndex uint32 `protobuf:"varint,2,opt,name=last_offset_index,json=lastOffsetIndex,proto3" json:"last_offset_index,omitempty"` } func (x *ForwardingHistoryResponse) Reset() { *x = ForwardingHistoryResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[152] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ForwardingHistoryResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ForwardingHistoryResponse) ProtoMessage() {} func (x *ForwardingHistoryResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[152] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ForwardingHistoryResponse.ProtoReflect.Descriptor instead. func (*ForwardingHistoryResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{152} } func (x *ForwardingHistoryResponse) GetForwardingEvents() []*ForwardingEvent { if x != nil { return x.ForwardingEvents } return nil } func (x *ForwardingHistoryResponse) GetLastOffsetIndex() uint32 { if x != nil { return x.LastOffsetIndex } return 0 } type ExportChannelBackupRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The target channel point to obtain a back up for. ChanPoint *ChannelPoint `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` } func (x *ExportChannelBackupRequest) Reset() { *x = ExportChannelBackupRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[153] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ExportChannelBackupRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ExportChannelBackupRequest) ProtoMessage() {} func (x *ExportChannelBackupRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[153] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ExportChannelBackupRequest.ProtoReflect.Descriptor instead. func (*ExportChannelBackupRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{153} } func (x *ExportChannelBackupRequest) GetChanPoint() *ChannelPoint { if x != nil { return x.ChanPoint } return nil } type ChannelBackup struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //Identifies the channel that this backup belongs to. ChanPoint *ChannelPoint `protobuf:"bytes,1,opt,name=chan_point,json=chanPoint,proto3" json:"chan_point,omitempty"` // //Is an encrypted single-chan backup. this can be passed to //RestoreChannelBackups, or the WalletUnlocker Init and Unlock methods in //order to trigger the recovery protocol. When using REST, this field must be //encoded as base64. ChanBackup []byte `protobuf:"bytes,2,opt,name=chan_backup,json=chanBackup,proto3" json:"chan_backup,omitempty"` } func (x *ChannelBackup) Reset() { *x = ChannelBackup{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[154] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelBackup) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelBackup) ProtoMessage() {} func (x *ChannelBackup) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[154] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelBackup.ProtoReflect.Descriptor instead. func (*ChannelBackup) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{154} } func (x *ChannelBackup) GetChanPoint() *ChannelPoint { if x != nil { return x.ChanPoint } return nil } func (x *ChannelBackup) GetChanBackup() []byte { if x != nil { return x.ChanBackup } return nil } type MultiChanBackup struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //Is the set of all channels that are included in this multi-channel backup. ChanPoints []*ChannelPoint `protobuf:"bytes,1,rep,name=chan_points,json=chanPoints,proto3" json:"chan_points,omitempty"` // //A single encrypted blob containing all the static channel backups of the //channel listed above. This can be stored as a single file or blob, and //safely be replaced with any prior/future versions. When using REST, this //field must be encoded as base64. MultiChanBackup []byte `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3" json:"multi_chan_backup,omitempty"` } func (x *MultiChanBackup) Reset() { *x = MultiChanBackup{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[155] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MultiChanBackup) String() string { return protoimpl.X.MessageStringOf(x) } func (*MultiChanBackup) ProtoMessage() {} func (x *MultiChanBackup) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[155] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MultiChanBackup.ProtoReflect.Descriptor instead. func (*MultiChanBackup) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{155} } func (x *MultiChanBackup) GetChanPoints() []*ChannelPoint { if x != nil { return x.ChanPoints } return nil } func (x *MultiChanBackup) GetMultiChanBackup() []byte { if x != nil { return x.MultiChanBackup } return nil } type ChanBackupExportRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ChanBackupExportRequest) Reset() { *x = ChanBackupExportRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[156] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChanBackupExportRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChanBackupExportRequest) ProtoMessage() {} func (x *ChanBackupExportRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[156] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChanBackupExportRequest.ProtoReflect.Descriptor instead. func (*ChanBackupExportRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{156} } type ChanBackupSnapshot struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The set of new channels that have been added since the last channel backup //snapshot was requested. SingleChanBackups *ChannelBackups `protobuf:"bytes,1,opt,name=single_chan_backups,json=singleChanBackups,proto3" json:"single_chan_backups,omitempty"` // //A multi-channel backup that covers all open channels currently known to //lnd. MultiChanBackup *MultiChanBackup `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3" json:"multi_chan_backup,omitempty"` } func (x *ChanBackupSnapshot) Reset() { *x = ChanBackupSnapshot{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[157] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChanBackupSnapshot) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChanBackupSnapshot) ProtoMessage() {} func (x *ChanBackupSnapshot) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[157] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChanBackupSnapshot.ProtoReflect.Descriptor instead. func (*ChanBackupSnapshot) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{157} } func (x *ChanBackupSnapshot) GetSingleChanBackups() *ChannelBackups { if x != nil { return x.SingleChanBackups } return nil } func (x *ChanBackupSnapshot) GetMultiChanBackup() *MultiChanBackup { if x != nil { return x.MultiChanBackup } return nil } type ChannelBackups struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A set of single-chan static channel backups. ChanBackups []*ChannelBackup `protobuf:"bytes,1,rep,name=chan_backups,json=chanBackups,proto3" json:"chan_backups,omitempty"` } func (x *ChannelBackups) Reset() { *x = ChannelBackups{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[158] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelBackups) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelBackups) ProtoMessage() {} func (x *ChannelBackups) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[158] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelBackups.ProtoReflect.Descriptor instead. func (*ChannelBackups) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{158} } func (x *ChannelBackups) GetChanBackups() []*ChannelBackup { if x != nil { return x.ChanBackups } return nil } type RestoreChanBackupRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Types that are assignable to Backup: // *RestoreChanBackupRequest_ChanBackups // *RestoreChanBackupRequest_MultiChanBackup Backup isRestoreChanBackupRequest_Backup `protobuf_oneof:"backup"` } func (x *RestoreChanBackupRequest) Reset() { *x = RestoreChanBackupRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[159] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RestoreChanBackupRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*RestoreChanBackupRequest) ProtoMessage() {} func (x *RestoreChanBackupRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[159] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RestoreChanBackupRequest.ProtoReflect.Descriptor instead. func (*RestoreChanBackupRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{159} } func (m *RestoreChanBackupRequest) GetBackup() isRestoreChanBackupRequest_Backup { if m != nil { return m.Backup } return nil } func (x *RestoreChanBackupRequest) GetChanBackups() *ChannelBackups { if x, ok := x.GetBackup().(*RestoreChanBackupRequest_ChanBackups); ok { return x.ChanBackups } return nil } func (x *RestoreChanBackupRequest) GetMultiChanBackup() []byte { if x, ok := x.GetBackup().(*RestoreChanBackupRequest_MultiChanBackup); ok { return x.MultiChanBackup } return nil } type isRestoreChanBackupRequest_Backup interface { isRestoreChanBackupRequest_Backup() } type RestoreChanBackupRequest_ChanBackups struct { // //The channels to restore as a list of channel/backup pairs. ChanBackups *ChannelBackups `protobuf:"bytes,1,opt,name=chan_backups,json=chanBackups,proto3,oneof"` } type RestoreChanBackupRequest_MultiChanBackup struct { // //The channels to restore in the packed multi backup format. When using //REST, this field must be encoded as base64. MultiChanBackup []byte `protobuf:"bytes,2,opt,name=multi_chan_backup,json=multiChanBackup,proto3,oneof"` } func (*RestoreChanBackupRequest_ChanBackups) isRestoreChanBackupRequest_Backup() {} func (*RestoreChanBackupRequest_MultiChanBackup) isRestoreChanBackupRequest_Backup() {} type RestoreBackupResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *RestoreBackupResponse) Reset() { *x = RestoreBackupResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[160] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RestoreBackupResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*RestoreBackupResponse) ProtoMessage() {} func (x *RestoreBackupResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[160] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RestoreBackupResponse.ProtoReflect.Descriptor instead. func (*RestoreBackupResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{160} } type ChannelBackupSubscription struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ChannelBackupSubscription) Reset() { *x = ChannelBackupSubscription{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[161] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelBackupSubscription) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelBackupSubscription) ProtoMessage() {} func (x *ChannelBackupSubscription) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[161] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelBackupSubscription.ProtoReflect.Descriptor instead. func (*ChannelBackupSubscription) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{161} } type VerifyChanBackupResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *VerifyChanBackupResponse) Reset() { *x = VerifyChanBackupResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[162] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *VerifyChanBackupResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*VerifyChanBackupResponse) ProtoMessage() {} func (x *VerifyChanBackupResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[162] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use VerifyChanBackupResponse.ProtoReflect.Descriptor instead. func (*VerifyChanBackupResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{162} } type MacaroonPermission struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The entity a permission grants access to. Entity string `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` // The action that is granted. Action string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"` } func (x *MacaroonPermission) Reset() { *x = MacaroonPermission{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[163] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MacaroonPermission) String() string { return protoimpl.X.MessageStringOf(x) } func (*MacaroonPermission) ProtoMessage() {} func (x *MacaroonPermission) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[163] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MacaroonPermission.ProtoReflect.Descriptor instead. func (*MacaroonPermission) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{163} } func (x *MacaroonPermission) GetEntity() string { if x != nil { return x.Entity } return "" } func (x *MacaroonPermission) GetAction() string { if x != nil { return x.Action } return "" } type BakeMacaroonRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of permissions the new macaroon should grant. Permissions []*MacaroonPermission `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"` // The root key ID used to create the macaroon, must be a positive integer. RootKeyId uint64 `protobuf:"varint,2,opt,name=root_key_id,json=rootKeyId,proto3" json:"root_key_id,omitempty"` // //Informs the RPC on whether to allow external permissions that LND is not //aware of. AllowExternalPermissions bool `protobuf:"varint,3,opt,name=allow_external_permissions,json=allowExternalPermissions,proto3" json:"allow_external_permissions,omitempty"` } func (x *BakeMacaroonRequest) Reset() { *x = BakeMacaroonRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[164] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *BakeMacaroonRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*BakeMacaroonRequest) ProtoMessage() {} func (x *BakeMacaroonRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[164] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use BakeMacaroonRequest.ProtoReflect.Descriptor instead. func (*BakeMacaroonRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{164} } func (x *BakeMacaroonRequest) GetPermissions() []*MacaroonPermission { if x != nil { return x.Permissions } return nil } func (x *BakeMacaroonRequest) GetRootKeyId() uint64 { if x != nil { return x.RootKeyId } return 0 } func (x *BakeMacaroonRequest) GetAllowExternalPermissions() bool { if x != nil { return x.AllowExternalPermissions } return false } type BakeMacaroonResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The hex encoded macaroon, serialized in binary format. Macaroon string `protobuf:"bytes,1,opt,name=macaroon,proto3" json:"macaroon,omitempty"` } func (x *BakeMacaroonResponse) Reset() { *x = BakeMacaroonResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[165] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *BakeMacaroonResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*BakeMacaroonResponse) ProtoMessage() {} func (x *BakeMacaroonResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[165] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use BakeMacaroonResponse.ProtoReflect.Descriptor instead. func (*BakeMacaroonResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{165} } func (x *BakeMacaroonResponse) GetMacaroon() string { if x != nil { return x.Macaroon } return "" } type ListMacaroonIDsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ListMacaroonIDsRequest) Reset() { *x = ListMacaroonIDsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[166] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListMacaroonIDsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListMacaroonIDsRequest) ProtoMessage() {} func (x *ListMacaroonIDsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[166] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListMacaroonIDsRequest.ProtoReflect.Descriptor instead. func (*ListMacaroonIDsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{166} } type ListMacaroonIDsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The list of root key IDs that are in use. RootKeyIds []uint64 `protobuf:"varint,1,rep,packed,name=root_key_ids,json=rootKeyIds,proto3" json:"root_key_ids,omitempty"` } func (x *ListMacaroonIDsResponse) Reset() { *x = ListMacaroonIDsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[167] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListMacaroonIDsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListMacaroonIDsResponse) ProtoMessage() {} func (x *ListMacaroonIDsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[167] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListMacaroonIDsResponse.ProtoReflect.Descriptor instead. func (*ListMacaroonIDsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{167} } func (x *ListMacaroonIDsResponse) GetRootKeyIds() []uint64 { if x != nil { return x.RootKeyIds } return nil } type DeleteMacaroonIDRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The root key ID to be removed. RootKeyId uint64 `protobuf:"varint,1,opt,name=root_key_id,json=rootKeyId,proto3" json:"root_key_id,omitempty"` } func (x *DeleteMacaroonIDRequest) Reset() { *x = DeleteMacaroonIDRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[168] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeleteMacaroonIDRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeleteMacaroonIDRequest) ProtoMessage() {} func (x *DeleteMacaroonIDRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[168] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeleteMacaroonIDRequest.ProtoReflect.Descriptor instead. func (*DeleteMacaroonIDRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{168} } func (x *DeleteMacaroonIDRequest) GetRootKeyId() uint64 { if x != nil { return x.RootKeyId } return 0 } type DeleteMacaroonIDResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // A boolean indicates that the deletion is successful. Deleted bool `protobuf:"varint,1,opt,name=deleted,proto3" json:"deleted,omitempty"` } func (x *DeleteMacaroonIDResponse) Reset() { *x = DeleteMacaroonIDResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[169] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *DeleteMacaroonIDResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*DeleteMacaroonIDResponse) ProtoMessage() {} func (x *DeleteMacaroonIDResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[169] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use DeleteMacaroonIDResponse.ProtoReflect.Descriptor instead. func (*DeleteMacaroonIDResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{169} } func (x *DeleteMacaroonIDResponse) GetDeleted() bool { if x != nil { return x.Deleted } return false } type MacaroonPermissionList struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // A list of macaroon permissions. Permissions []*MacaroonPermission `protobuf:"bytes,1,rep,name=permissions,proto3" json:"permissions,omitempty"` } func (x *MacaroonPermissionList) Reset() { *x = MacaroonPermissionList{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[170] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MacaroonPermissionList) String() string { return protoimpl.X.MessageStringOf(x) } func (*MacaroonPermissionList) ProtoMessage() {} func (x *MacaroonPermissionList) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[170] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MacaroonPermissionList.ProtoReflect.Descriptor instead. func (*MacaroonPermissionList) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{170} } func (x *MacaroonPermissionList) GetPermissions() []*MacaroonPermission { if x != nil { return x.Permissions } return nil } type ListPermissionsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields } func (x *ListPermissionsRequest) Reset() { *x = ListPermissionsRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[171] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPermissionsRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPermissionsRequest) ProtoMessage() {} func (x *ListPermissionsRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[171] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPermissionsRequest.ProtoReflect.Descriptor instead. func (*ListPermissionsRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{171} } type ListPermissionsResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //A map between all RPC method URIs and their required macaroon permissions to //access them. MethodPermissions map[string]*MacaroonPermissionList `protobuf:"bytes,1,rep,name=method_permissions,json=methodPermissions,proto3" json:"method_permissions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *ListPermissionsResponse) Reset() { *x = ListPermissionsResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[172] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ListPermissionsResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*ListPermissionsResponse) ProtoMessage() {} func (x *ListPermissionsResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[172] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ListPermissionsResponse.ProtoReflect.Descriptor instead. func (*ListPermissionsResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{172} } func (x *ListPermissionsResponse) GetMethodPermissions() map[string]*MacaroonPermissionList { if x != nil { return x.MethodPermissions } return nil } type Failure struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Failure code as defined in the Lightning spec Code Failure_FailureCode `protobuf:"varint,1,opt,name=code,proto3,enum=lnrpc.Failure_FailureCode" json:"code,omitempty"` // An optional channel update message. ChannelUpdate *ChannelUpdate `protobuf:"bytes,3,opt,name=channel_update,json=channelUpdate,proto3" json:"channel_update,omitempty"` // A failure type-dependent htlc value. HtlcMsat uint64 `protobuf:"varint,4,opt,name=htlc_msat,json=htlcMsat,proto3" json:"htlc_msat,omitempty"` // The sha256 sum of the onion payload. OnionSha_256 []byte `protobuf:"bytes,5,opt,name=onion_sha_256,json=onionSha256,proto3" json:"onion_sha_256,omitempty"` // A failure type-dependent cltv expiry value. CltvExpiry uint32 `protobuf:"varint,6,opt,name=cltv_expiry,json=cltvExpiry,proto3" json:"cltv_expiry,omitempty"` // A failure type-dependent flags value. Flags uint32 `protobuf:"varint,7,opt,name=flags,proto3" json:"flags,omitempty"` // //The position in the path of the intermediate or final node that generated //the failure message. Position zero is the sender node. FailureSourceIndex uint32 `protobuf:"varint,8,opt,name=failure_source_index,json=failureSourceIndex,proto3" json:"failure_source_index,omitempty"` // A failure type-dependent block height. Height uint32 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"` } func (x *Failure) Reset() { *x = Failure{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[173] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Failure) String() string { return protoimpl.X.MessageStringOf(x) } func (*Failure) ProtoMessage() {} func (x *Failure) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[173] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Failure.ProtoReflect.Descriptor instead. func (*Failure) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{173} } func (x *Failure) GetCode() Failure_FailureCode { if x != nil { return x.Code } return Failure_RESERVED } func (x *Failure) GetChannelUpdate() *ChannelUpdate { if x != nil { return x.ChannelUpdate } return nil } func (x *Failure) GetHtlcMsat() uint64 { if x != nil { return x.HtlcMsat } return 0 } func (x *Failure) GetOnionSha_256() []byte { if x != nil { return x.OnionSha_256 } return nil } func (x *Failure) GetCltvExpiry() uint32 { if x != nil { return x.CltvExpiry } return 0 } func (x *Failure) GetFlags() uint32 { if x != nil { return x.Flags } return 0 } func (x *Failure) GetFailureSourceIndex() uint32 { if x != nil { return x.FailureSourceIndex } return 0 } func (x *Failure) GetHeight() uint32 { if x != nil { return x.Height } return 0 } type ChannelUpdate struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The signature that validates the announced data and proves the ownership //of node id. Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"` // //The target chain that this channel was opened within. This value //should be the genesis hash of the target chain. Along with the short //channel ID, this uniquely identifies the channel globally in a //blockchain. ChainHash []byte `protobuf:"bytes,2,opt,name=chain_hash,json=chainHash,proto3" json:"chain_hash,omitempty"` // //The unique description of the funding transaction. ChanId uint64 `protobuf:"varint,3,opt,name=chan_id,json=chanId,proto3" json:"chan_id,omitempty"` // //A timestamp that allows ordering in the case of multiple announcements. //We should ignore the message if timestamp is not greater than the //last-received. Timestamp uint32 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // //The bitfield that describes whether optional fields are present in this //update. Currently, the least-significant bit must be set to 1 if the //optional field MaxHtlc is present. MessageFlags uint32 `protobuf:"varint,10,opt,name=message_flags,json=messageFlags,proto3" json:"message_flags,omitempty"` // //The bitfield that describes additional meta-data concerning how the //update is to be interpreted. Currently, the least-significant bit must be //set to 0 if the creating node corresponds to the first node in the //previously sent channel announcement and 1 otherwise. If the second bit //is set, then the channel is set to be disabled. ChannelFlags uint32 `protobuf:"varint,5,opt,name=channel_flags,json=channelFlags,proto3" json:"channel_flags,omitempty"` // //The minimum number of blocks this node requires to be added to the expiry //of HTLCs. This is a security parameter determined by the node operator. //This value represents the required gap between the time locks of the //incoming and outgoing HTLC's set to this node. TimeLockDelta uint32 `protobuf:"varint,6,opt,name=time_lock_delta,json=timeLockDelta,proto3" json:"time_lock_delta,omitempty"` // //The minimum HTLC value which will be accepted. HtlcMinimumMsat uint64 `protobuf:"varint,7,opt,name=htlc_minimum_msat,json=htlcMinimumMsat,proto3" json:"htlc_minimum_msat,omitempty"` // //The base fee that must be used for incoming HTLC's to this particular //channel. This value will be tacked onto the required for a payment //independent of the size of the payment. BaseFee uint32 `protobuf:"varint,8,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"` // //The fee rate that will be charged per millionth of a satoshi. FeeRate uint32 `protobuf:"varint,9,opt,name=fee_rate,json=feeRate,proto3" json:"fee_rate,omitempty"` // //The maximum HTLC value which will be accepted. HtlcMaximumMsat uint64 `protobuf:"varint,11,opt,name=htlc_maximum_msat,json=htlcMaximumMsat,proto3" json:"htlc_maximum_msat,omitempty"` // //The set of data that was appended to this message, some of which we may //not actually know how to iterate or parse. By holding onto this data, we //ensure that we're able to properly validate the set of signatures that //cover these new fields, and ensure we're able to make upgrades to the //network in a forwards compatible manner. ExtraOpaqueData []byte `protobuf:"bytes,12,opt,name=extra_opaque_data,json=extraOpaqueData,proto3" json:"extra_opaque_data,omitempty"` } func (x *ChannelUpdate) Reset() { *x = ChannelUpdate{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[174] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *ChannelUpdate) String() string { return protoimpl.X.MessageStringOf(x) } func (*ChannelUpdate) ProtoMessage() {} func (x *ChannelUpdate) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[174] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use ChannelUpdate.ProtoReflect.Descriptor instead. func (*ChannelUpdate) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{174} } func (x *ChannelUpdate) GetSignature() []byte { if x != nil { return x.Signature } return nil } func (x *ChannelUpdate) GetChainHash() []byte { if x != nil { return x.ChainHash } return nil } func (x *ChannelUpdate) GetChanId() uint64 { if x != nil { return x.ChanId } return 0 } func (x *ChannelUpdate) GetTimestamp() uint32 { if x != nil { return x.Timestamp } return 0 } func (x *ChannelUpdate) GetMessageFlags() uint32 { if x != nil { return x.MessageFlags } return 0 } func (x *ChannelUpdate) GetChannelFlags() uint32 { if x != nil { return x.ChannelFlags } return 0 } func (x *ChannelUpdate) GetTimeLockDelta() uint32 { if x != nil { return x.TimeLockDelta } return 0 } func (x *ChannelUpdate) GetHtlcMinimumMsat() uint64 { if x != nil { return x.HtlcMinimumMsat } return 0 } func (x *ChannelUpdate) GetBaseFee() uint32 { if x != nil { return x.BaseFee } return 0 } func (x *ChannelUpdate) GetFeeRate() uint32 { if x != nil { return x.FeeRate } return 0 } func (x *ChannelUpdate) GetHtlcMaximumMsat() uint64 { if x != nil { return x.HtlcMaximumMsat } return 0 } func (x *ChannelUpdate) GetExtraOpaqueData() []byte { if x != nil { return x.ExtraOpaqueData } return nil } type MacaroonId struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Nonce []byte `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"` StorageId []byte `protobuf:"bytes,2,opt,name=storageId,proto3" json:"storageId,omitempty"` Ops []*Op `protobuf:"bytes,3,rep,name=ops,proto3" json:"ops,omitempty"` } func (x *MacaroonId) Reset() { *x = MacaroonId{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[175] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MacaroonId) String() string { return protoimpl.X.MessageStringOf(x) } func (*MacaroonId) ProtoMessage() {} func (x *MacaroonId) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[175] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MacaroonId.ProtoReflect.Descriptor instead. func (*MacaroonId) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{175} } func (x *MacaroonId) GetNonce() []byte { if x != nil { return x.Nonce } return nil } func (x *MacaroonId) GetStorageId() []byte { if x != nil { return x.StorageId } return nil } func (x *MacaroonId) GetOps() []*Op { if x != nil { return x.Ops } return nil } type Op struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Entity string `protobuf:"bytes,1,opt,name=entity,proto3" json:"entity,omitempty"` Actions []string `protobuf:"bytes,2,rep,name=actions,proto3" json:"actions,omitempty"` } func (x *Op) Reset() { *x = Op{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[176] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *Op) String() string { return protoimpl.X.MessageStringOf(x) } func (*Op) ProtoMessage() {} func (x *Op) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[176] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use Op.ProtoReflect.Descriptor instead. func (*Op) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{176} } func (x *Op) GetEntity() string { if x != nil { return x.Entity } return "" } func (x *Op) GetActions() []string { if x != nil { return x.Actions } return nil } type CheckMacPermRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Macaroon []byte `protobuf:"bytes,1,opt,name=macaroon,proto3" json:"macaroon,omitempty"` Permissions []*MacaroonPermission `protobuf:"bytes,2,rep,name=permissions,proto3" json:"permissions,omitempty"` FullMethod string `protobuf:"bytes,3,opt,name=fullMethod,proto3" json:"fullMethod,omitempty"` } func (x *CheckMacPermRequest) Reset() { *x = CheckMacPermRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[177] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *CheckMacPermRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*CheckMacPermRequest) ProtoMessage() {} func (x *CheckMacPermRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[177] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use CheckMacPermRequest.ProtoReflect.Descriptor instead. func (*CheckMacPermRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{177} } func (x *CheckMacPermRequest) GetMacaroon() []byte { if x != nil { return x.Macaroon } return nil } func (x *CheckMacPermRequest) GetPermissions() []*MacaroonPermission { if x != nil { return x.Permissions } return nil } func (x *CheckMacPermRequest) GetFullMethod() string { if x != nil { return x.FullMethod } return "" } type CheckMacPermResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"` } func (x *CheckMacPermResponse) Reset() { *x = CheckMacPermResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[178] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *CheckMacPermResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*CheckMacPermResponse) ProtoMessage() {} func (x *CheckMacPermResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[178] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use CheckMacPermResponse.ProtoReflect.Descriptor instead. func (*CheckMacPermResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{178} } func (x *CheckMacPermResponse) GetValid() bool { if x != nil { return x.Valid } return false } type RPCMiddlewareRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The unique ID of the intercepted original gRPC request. Useful for mapping //request to response when implementing full duplex message interception. For //streaming requests, this will be the same ID for all incoming and outgoing //middleware intercept messages of the _same_ stream. RequestId uint64 `protobuf:"varint,1,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` // //The raw bytes of the complete macaroon as sent by the gRPC client in the //original request. This might be empty for a request that doesn't require //macaroons such as the wallet unlocker RPCs. RawMacaroon []byte `protobuf:"bytes,2,opt,name=raw_macaroon,json=rawMacaroon,proto3" json:"raw_macaroon,omitempty"` // //The parsed condition of the macaroon's custom caveat for convenient access. //This field only contains the value of the custom caveat that the handling //middleware has registered itself for. The condition _must_ be validated for //messages of intercept_type stream_auth and request! CustomCaveatCondition string `protobuf:"bytes,3,opt,name=custom_caveat_condition,json=customCaveatCondition,proto3" json:"custom_caveat_condition,omitempty"` // //There are three types of messages that will be sent to the middleware for //inspection and approval: Stream authentication, request and response //interception. The first two can only be accepted (=forward to main RPC //server) or denied (=return error to client). Intercepted responses can also //be replaced/overwritten. // // Types that are assignable to InterceptType: // *RPCMiddlewareRequest_StreamAuth // *RPCMiddlewareRequest_Request // *RPCMiddlewareRequest_Response InterceptType isRPCMiddlewareRequest_InterceptType `protobuf_oneof:"intercept_type"` // //The unique message ID of this middleware intercept message. There can be //multiple middleware intercept messages per single gRPC request (one for the //incoming request and one for the outgoing response) or gRPC stream (one for //each incoming message and one for each outgoing response). This message ID //must be referenced when responding (accepting/rejecting/modifying) to an //intercept message. MsgId uint64 `protobuf:"varint,7,opt,name=msg_id,json=msgId,proto3" json:"msg_id,omitempty"` } func (x *RPCMiddlewareRequest) Reset() { *x = RPCMiddlewareRequest{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[179] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RPCMiddlewareRequest) String() string { return protoimpl.X.MessageStringOf(x) } func (*RPCMiddlewareRequest) ProtoMessage() {} func (x *RPCMiddlewareRequest) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[179] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RPCMiddlewareRequest.ProtoReflect.Descriptor instead. func (*RPCMiddlewareRequest) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{179} } func (x *RPCMiddlewareRequest) GetRequestId() uint64 { if x != nil { return x.RequestId } return 0 } func (x *RPCMiddlewareRequest) GetRawMacaroon() []byte { if x != nil { return x.RawMacaroon } return nil } func (x *RPCMiddlewareRequest) GetCustomCaveatCondition() string { if x != nil { return x.CustomCaveatCondition } return "" } func (m *RPCMiddlewareRequest) GetInterceptType() isRPCMiddlewareRequest_InterceptType { if m != nil { return m.InterceptType } return nil } func (x *RPCMiddlewareRequest) GetStreamAuth() *StreamAuth { if x, ok := x.GetInterceptType().(*RPCMiddlewareRequest_StreamAuth); ok { return x.StreamAuth } return nil } func (x *RPCMiddlewareRequest) GetRequest() *RPCMessage { if x, ok := x.GetInterceptType().(*RPCMiddlewareRequest_Request); ok { return x.Request } return nil } func (x *RPCMiddlewareRequest) GetResponse() *RPCMessage { if x, ok := x.GetInterceptType().(*RPCMiddlewareRequest_Response); ok { return x.Response } return nil } func (x *RPCMiddlewareRequest) GetMsgId() uint64 { if x != nil { return x.MsgId } return 0 } type isRPCMiddlewareRequest_InterceptType interface { isRPCMiddlewareRequest_InterceptType() } type RPCMiddlewareRequest_StreamAuth struct { // //Intercept stream authentication: each new streaming RPC call that is //initiated against lnd and contains the middleware's custom macaroon //caveat can be approved or denied based upon the macaroon in the stream //header. This message will only be sent for streaming RPCs, unary RPCs //must handle the macaroon authentication in the request interception to //avoid an additional message round trip between lnd and the middleware. StreamAuth *StreamAuth `protobuf:"bytes,4,opt,name=stream_auth,json=streamAuth,proto3,oneof"` } type RPCMiddlewareRequest_Request struct { // //Intercept incoming gRPC client request message: all incoming messages, //both on streaming and unary RPCs, are forwarded to the middleware for //inspection. For unary RPC messages the middleware is also expected to //validate the custom macaroon caveat of the request. Request *RPCMessage `protobuf:"bytes,5,opt,name=request,proto3,oneof"` } type RPCMiddlewareRequest_Response struct { // //Intercept outgoing gRPC response message: all outgoing messages, both on //streaming and unary RPCs, are forwarded to the middleware for inspection //and amendment. The response in this message is the original response as //it was generated by the main RPC server. It can either be accepted //(=forwarded to the client), replaced/overwritten with a new message of //the same type, or replaced by an error message. Response *RPCMessage `protobuf:"bytes,6,opt,name=response,proto3,oneof"` } func (*RPCMiddlewareRequest_StreamAuth) isRPCMiddlewareRequest_InterceptType() {} func (*RPCMiddlewareRequest_Request) isRPCMiddlewareRequest_InterceptType() {} func (*RPCMiddlewareRequest_Response) isRPCMiddlewareRequest_InterceptType() {} type StreamAuth struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The full URI (in the format /<rpcpackage>.<ServiceName>/MethodName, for //example /lnrpc.Lightning/GetInfo) of the streaming RPC method that was just //established. MethodFullUri string `protobuf:"bytes,1,opt,name=method_full_uri,json=methodFullUri,proto3" json:"method_full_uri,omitempty"` } func (x *StreamAuth) Reset() { *x = StreamAuth{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[180] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *StreamAuth) String() string { return protoimpl.X.MessageStringOf(x) } func (*StreamAuth) ProtoMessage() {} func (x *StreamAuth) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[180] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use StreamAuth.ProtoReflect.Descriptor instead. func (*StreamAuth) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{180} } func (x *StreamAuth) GetMethodFullUri() string { if x != nil { return x.MethodFullUri } return "" } type RPCMessage struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The full URI (in the format /<rpcpackage>.<ServiceName>/MethodName, for //example /lnrpc.Lightning/GetInfo) of the RPC method the message was sent //to/from. MethodFullUri string `protobuf:"bytes,1,opt,name=method_full_uri,json=methodFullUri,proto3" json:"method_full_uri,omitempty"` // //Indicates whether the message was sent over a streaming RPC method or not. StreamRpc bool `protobuf:"varint,2,opt,name=stream_rpc,json=streamRpc,proto3" json:"stream_rpc,omitempty"` // //The full canonical gRPC name of the message type (in the format //<rpcpackage>.TypeName, for example lnrpc.GetInfoRequest). TypeName string `protobuf:"bytes,3,opt,name=type_name,json=typeName,proto3" json:"type_name,omitempty"` // //The full content of the gRPC message, serialized in the binary protobuf //format. Serialized []byte `protobuf:"bytes,4,opt,name=serialized,proto3" json:"serialized,omitempty"` } func (x *RPCMessage) Reset() { *x = RPCMessage{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[181] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RPCMessage) String() string { return protoimpl.X.MessageStringOf(x) } func (*RPCMessage) ProtoMessage() {} func (x *RPCMessage) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[181] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RPCMessage.ProtoReflect.Descriptor instead. func (*RPCMessage) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{181} } func (x *RPCMessage) GetMethodFullUri() string { if x != nil { return x.MethodFullUri } return "" } func (x *RPCMessage) GetStreamRpc() bool { if x != nil { return x.StreamRpc } return false } func (x *RPCMessage) GetTypeName() string { if x != nil { return x.TypeName } return "" } func (x *RPCMessage) GetSerialized() []byte { if x != nil { return x.Serialized } return nil } type RPCMiddlewareResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The request message ID this response refers to. Must always be set when //giving feedback to an intercept but is ignored for the initial registration //message. RefMsgId uint64 `protobuf:"varint,1,opt,name=ref_msg_id,json=refMsgId,proto3" json:"ref_msg_id,omitempty"` // //The middleware can only send two types of messages to lnd: The initial //registration message that identifies the middleware and after that only //feedback messages to requests sent to the middleware. // // Types that are assignable to MiddlewareMessage: // *RPCMiddlewareResponse_Register // *RPCMiddlewareResponse_Feedback MiddlewareMessage isRPCMiddlewareResponse_MiddlewareMessage `protobuf_oneof:"middleware_message"` } func (x *RPCMiddlewareResponse) Reset() { *x = RPCMiddlewareResponse{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[182] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *RPCMiddlewareResponse) String() string { return protoimpl.X.MessageStringOf(x) } func (*RPCMiddlewareResponse) ProtoMessage() {} func (x *RPCMiddlewareResponse) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[182] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use RPCMiddlewareResponse.ProtoReflect.Descriptor instead. func (*RPCMiddlewareResponse) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{182} } func (x *RPCMiddlewareResponse) GetRefMsgId() uint64 { if x != nil { return x.RefMsgId } return 0 } func (m *RPCMiddlewareResponse) GetMiddlewareMessage() isRPCMiddlewareResponse_MiddlewareMessage { if m != nil { return m.MiddlewareMessage } return nil } func (x *RPCMiddlewareResponse) GetRegister() *MiddlewareRegistration { if x, ok := x.GetMiddlewareMessage().(*RPCMiddlewareResponse_Register); ok { return x.Register } return nil } func (x *RPCMiddlewareResponse) GetFeedback() *InterceptFeedback { if x, ok := x.GetMiddlewareMessage().(*RPCMiddlewareResponse_Feedback); ok { return x.Feedback } return nil } type isRPCMiddlewareResponse_MiddlewareMessage interface { isRPCMiddlewareResponse_MiddlewareMessage() } type RPCMiddlewareResponse_Register struct { // //The registration message identifies the middleware that's being //registered in lnd. The registration message must be sent immediately //after initiating the RegisterRpcMiddleware stream, otherwise lnd will //time out the attempt and terminate the request. NOTE: The middleware //will only receive interception messages for requests that contain a //macaroon with the custom caveat that the middleware declares it is //responsible for handling in the registration message! As a security //measure, _no_ middleware can intercept requests made with _unencumbered_ //macaroons! Register *MiddlewareRegistration `protobuf:"bytes,2,opt,name=register,proto3,oneof"` } type RPCMiddlewareResponse_Feedback struct { // //The middleware received an interception request and gives feedback to //it. The request_id indicates what message the feedback refers to. Feedback *InterceptFeedback `protobuf:"bytes,3,opt,name=feedback,proto3,oneof"` } func (*RPCMiddlewareResponse_Register) isRPCMiddlewareResponse_MiddlewareMessage() {} func (*RPCMiddlewareResponse_Feedback) isRPCMiddlewareResponse_MiddlewareMessage() {} type MiddlewareRegistration struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The name of the middleware to register. The name should be as informative //as possible and is logged on registration. MiddlewareName string `protobuf:"bytes,1,opt,name=middleware_name,json=middlewareName,proto3" json:"middleware_name,omitempty"` // //The name of the custom macaroon caveat that this middleware is responsible //for. Only requests/responses that contain a macaroon with the registered //custom caveat are forwarded for interception to the middleware. The //exception being the read-only mode: All requests/responses are forwarded to //a middleware that requests read-only access but such a middleware won't be //allowed to _alter_ responses. As a security measure, _no_ middleware can //change responses to requests made with _unencumbered_ macaroons! //NOTE: Cannot be used at the same time as read_only_mode. CustomMacaroonCaveatName string `protobuf:"bytes,2,opt,name=custom_macaroon_caveat_name,json=customMacaroonCaveatName,proto3" json:"custom_macaroon_caveat_name,omitempty"` // //Instead of defining a custom macaroon caveat name a middleware can register //itself for read-only access only. In that mode all requests/responses are //forwarded to the middleware but the middleware isn't allowed to alter any of //the responses. //NOTE: Cannot be used at the same time as custom_macaroon_caveat_name. ReadOnlyMode bool `protobuf:"varint,3,opt,name=read_only_mode,json=readOnlyMode,proto3" json:"read_only_mode,omitempty"` } func (x *MiddlewareRegistration) Reset() { *x = MiddlewareRegistration{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[183] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *MiddlewareRegistration) String() string { return protoimpl.X.MessageStringOf(x) } func (*MiddlewareRegistration) ProtoMessage() {} func (x *MiddlewareRegistration) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[183] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use MiddlewareRegistration.ProtoReflect.Descriptor instead. func (*MiddlewareRegistration) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{183} } func (x *MiddlewareRegistration) GetMiddlewareName() string { if x != nil { return x.MiddlewareName } return "" } func (x *MiddlewareRegistration) GetCustomMacaroonCaveatName() string { if x != nil { return x.CustomMacaroonCaveatName } return "" } func (x *MiddlewareRegistration) GetReadOnlyMode() bool { if x != nil { return x.ReadOnlyMode } return false } type InterceptFeedback struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // //The error to return to the user. If this is non-empty, the incoming gRPC //stream/request is aborted and the error is returned to the gRPC client. If //this value is empty, it means the middleware accepts the stream/request/ //response and the processing of it can continue. Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` // //A boolean indicating that the gRPC response should be replaced/overwritten. //As its name suggests, this can only be used as a feedback to an intercepted //response RPC message and is ignored for feedback on any other message. This //boolean is needed because in protobuf an empty message is serialized as a //0-length or nil byte slice and we wouldn't be able to distinguish between //an empty replacement message and the "don't replace anything" case. ReplaceResponse bool `protobuf:"varint,2,opt,name=replace_response,json=replaceResponse,proto3" json:"replace_response,omitempty"` // //If the replace_response field is set to true, this field must contain the //binary serialized gRPC response message in the protobuf format. ReplacementSerialized []byte `protobuf:"bytes,3,opt,name=replacement_serialized,json=replacementSerialized,proto3" json:"replacement_serialized,omitempty"` } func (x *InterceptFeedback) Reset() { *x = InterceptFeedback{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[184] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *InterceptFeedback) String() string { return protoimpl.X.MessageStringOf(x) } func (*InterceptFeedback) ProtoMessage() {} func (x *InterceptFeedback) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[184] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use InterceptFeedback.ProtoReflect.Descriptor instead. func (*InterceptFeedback) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{184} } func (x *InterceptFeedback) GetError() string { if x != nil { return x.Error } return "" } func (x *InterceptFeedback) GetReplaceResponse() bool { if x != nil { return x.ReplaceResponse } return false } func (x *InterceptFeedback) GetReplacementSerialized() []byte { if x != nil { return x.ReplacementSerialized } return nil } type PendingChannelsResponse_PendingChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields RemoteNodePub string `protobuf:"bytes,1,opt,name=remote_node_pub,json=remoteNodePub,proto3" json:"remote_node_pub,omitempty"` ChannelPoint string `protobuf:"bytes,2,opt,name=channel_point,json=channelPoint,proto3" json:"channel_point,omitempty"` Capacity int64 `protobuf:"varint,3,opt,name=capacity,proto3" json:"capacity,omitempty"` LocalBalance int64 `protobuf:"varint,4,opt,name=local_balance,json=localBalance,proto3" json:"local_balance,omitempty"` RemoteBalance int64 `protobuf:"varint,5,opt,name=remote_balance,json=remoteBalance,proto3" json:"remote_balance,omitempty"` // The minimum satoshis this node is required to reserve in its // balance. LocalChanReserveSat int64 `protobuf:"varint,6,opt,name=local_chan_reserve_sat,json=localChanReserveSat,proto3" json:"local_chan_reserve_sat,omitempty"` // //The minimum satoshis the other node is required to reserve in its //balance. RemoteChanReserveSat int64 `protobuf:"varint,7,opt,name=remote_chan_reserve_sat,json=remoteChanReserveSat,proto3" json:"remote_chan_reserve_sat,omitempty"` // The party that initiated opening the channel. Initiator Initiator `protobuf:"varint,8,opt,name=initiator,proto3,enum=lnrpc.Initiator" json:"initiator,omitempty"` // The commitment type used by this channel. CommitmentType CommitmentType `protobuf:"varint,9,opt,name=commitment_type,json=commitmentType,proto3,enum=lnrpc.CommitmentType" json:"commitment_type,omitempty"` // Total number of forwarding packages created in this channel. NumForwardingPackages int64 `protobuf:"varint,10,opt,name=num_forwarding_packages,json=numForwardingPackages,proto3" json:"num_forwarding_packages,omitempty"` } func (x *PendingChannelsResponse_PendingChannel) Reset() { *x = PendingChannelsResponse_PendingChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[190] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_PendingChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_PendingChannel) ProtoMessage() {} func (x *PendingChannelsResponse_PendingChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[190] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_PendingChannel.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_PendingChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 0} } func (x *PendingChannelsResponse_PendingChannel) GetRemoteNodePub() string { if x != nil { return x.RemoteNodePub } return "" } func (x *PendingChannelsResponse_PendingChannel) GetChannelPoint() string { if x != nil { return x.ChannelPoint } return "" } func (x *PendingChannelsResponse_PendingChannel) GetCapacity() int64 { if x != nil { return x.Capacity } return 0 } func (x *PendingChannelsResponse_PendingChannel) GetLocalBalance() int64 { if x != nil { return x.LocalBalance } return 0 } func (x *PendingChannelsResponse_PendingChannel) GetRemoteBalance() int64 { if x != nil { return x.RemoteBalance } return 0 } func (x *PendingChannelsResponse_PendingChannel) GetLocalChanReserveSat() int64 { if x != nil { return x.LocalChanReserveSat } return 0 } func (x *PendingChannelsResponse_PendingChannel) GetRemoteChanReserveSat() int64 { if x != nil { return x.RemoteChanReserveSat } return 0 } func (x *PendingChannelsResponse_PendingChannel) GetInitiator() Initiator { if x != nil { return x.Initiator } return Initiator_INITIATOR_UNKNOWN } func (x *PendingChannelsResponse_PendingChannel) GetCommitmentType() CommitmentType { if x != nil { return x.CommitmentType } return CommitmentType_UNKNOWN_COMMITMENT_TYPE } func (x *PendingChannelsResponse_PendingChannel) GetNumForwardingPackages() int64 { if x != nil { return x.NumForwardingPackages } return 0 } type PendingChannelsResponse_PendingOpenChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pending channel Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` // The height at which this channel will be confirmed ConfirmationHeight uint32 `protobuf:"varint,2,opt,name=confirmation_height,json=confirmationHeight,proto3" json:"confirmation_height,omitempty"` // //The amount calculated to be paid in fees for the current set of //commitment transactions. The fee amount is persisted with the channel //in order to allow the fee amount to be removed and recalculated with //each channel state update, including updates that happen after a system //restart. CommitFee int64 `protobuf:"varint,4,opt,name=commit_fee,json=commitFee,proto3" json:"commit_fee,omitempty"` // The weight of the commitment transaction CommitWeight int64 `protobuf:"varint,5,opt,name=commit_weight,json=commitWeight,proto3" json:"commit_weight,omitempty"` // //The required number of satoshis per kilo-weight that the requester will //pay at all times, for both the funding transaction and commitment //transaction. This value can later be updated once the channel is open. FeePerKw int64 `protobuf:"varint,6,opt,name=fee_per_kw,json=feePerKw,proto3" json:"fee_per_kw,omitempty"` } func (x *PendingChannelsResponse_PendingOpenChannel) Reset() { *x = PendingChannelsResponse_PendingOpenChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[191] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_PendingOpenChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_PendingOpenChannel) ProtoMessage() {} func (x *PendingChannelsResponse_PendingOpenChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[191] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_PendingOpenChannel.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_PendingOpenChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 1} } func (x *PendingChannelsResponse_PendingOpenChannel) GetChannel() *PendingChannelsResponse_PendingChannel { if x != nil { return x.Channel } return nil } func (x *PendingChannelsResponse_PendingOpenChannel) GetConfirmationHeight() uint32 { if x != nil { return x.ConfirmationHeight } return 0 } func (x *PendingChannelsResponse_PendingOpenChannel) GetCommitFee() int64 { if x != nil { return x.CommitFee } return 0 } func (x *PendingChannelsResponse_PendingOpenChannel) GetCommitWeight() int64 { if x != nil { return x.CommitWeight } return 0 } func (x *PendingChannelsResponse_PendingOpenChannel) GetFeePerKw() int64 { if x != nil { return x.FeePerKw } return 0 } type PendingChannelsResponse_WaitingCloseChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pending channel waiting for closing tx to confirm Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` // The balance in satoshis encumbered in this channel LimboBalance int64 `protobuf:"varint,2,opt,name=limbo_balance,json=limboBalance,proto3" json:"limbo_balance,omitempty"` // //A list of valid commitment transactions. Any of these can confirm at //this point. Commitments *PendingChannelsResponse_Commitments `protobuf:"bytes,3,opt,name=commitments,proto3" json:"commitments,omitempty"` } func (x *PendingChannelsResponse_WaitingCloseChannel) Reset() { *x = PendingChannelsResponse_WaitingCloseChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[192] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_WaitingCloseChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_WaitingCloseChannel) ProtoMessage() {} func (x *PendingChannelsResponse_WaitingCloseChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[192] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_WaitingCloseChannel.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_WaitingCloseChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 2} } func (x *PendingChannelsResponse_WaitingCloseChannel) GetChannel() *PendingChannelsResponse_PendingChannel { if x != nil { return x.Channel } return nil } func (x *PendingChannelsResponse_WaitingCloseChannel) GetLimboBalance() int64 { if x != nil { return x.LimboBalance } return 0 } func (x *PendingChannelsResponse_WaitingCloseChannel) GetCommitments() *PendingChannelsResponse_Commitments { if x != nil { return x.Commitments } return nil } type PendingChannelsResponse_Commitments struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // Hash of the local version of the commitment tx. LocalTxid string `protobuf:"bytes,1,opt,name=local_txid,json=localTxid,proto3" json:"local_txid,omitempty"` // Hash of the remote version of the commitment tx. RemoteTxid string `protobuf:"bytes,2,opt,name=remote_txid,json=remoteTxid,proto3" json:"remote_txid,omitempty"` // Hash of the remote pending version of the commitment tx. RemotePendingTxid string `protobuf:"bytes,3,opt,name=remote_pending_txid,json=remotePendingTxid,proto3" json:"remote_pending_txid,omitempty"` // //The amount in satoshis calculated to be paid in fees for the local //commitment. LocalCommitFeeSat uint64 `protobuf:"varint,4,opt,name=local_commit_fee_sat,json=localCommitFeeSat,proto3" json:"local_commit_fee_sat,omitempty"` // //The amount in satoshis calculated to be paid in fees for the remote //commitment. RemoteCommitFeeSat uint64 `protobuf:"varint,5,opt,name=remote_commit_fee_sat,json=remoteCommitFeeSat,proto3" json:"remote_commit_fee_sat,omitempty"` // //The amount in satoshis calculated to be paid in fees for the remote //pending commitment. RemotePendingCommitFeeSat uint64 `protobuf:"varint,6,opt,name=remote_pending_commit_fee_sat,json=remotePendingCommitFeeSat,proto3" json:"remote_pending_commit_fee_sat,omitempty"` } func (x *PendingChannelsResponse_Commitments) Reset() { *x = PendingChannelsResponse_Commitments{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[193] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_Commitments) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_Commitments) ProtoMessage() {} func (x *PendingChannelsResponse_Commitments) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[193] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil
return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_Commitments.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_Commitments) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 3} } func (x *PendingChannelsResponse_Commitments) GetLocalTxid() string { if x != nil { return x.LocalTxid } return "" } func (x *PendingChannelsResponse_Commitments) GetRemoteTxid() string { if x != nil { return x.RemoteTxid } return "" } func (x *PendingChannelsResponse_Commitments) GetRemotePendingTxid() string { if x != nil { return x.RemotePendingTxid } return "" } func (x *PendingChannelsResponse_Commitments) GetLocalCommitFeeSat() uint64 { if x != nil { return x.LocalCommitFeeSat } return 0 } func (x *PendingChannelsResponse_Commitments) GetRemoteCommitFeeSat() uint64 { if x != nil { return x.RemoteCommitFeeSat } return 0 } func (x *PendingChannelsResponse_Commitments) GetRemotePendingCommitFeeSat() uint64 { if x != nil { return x.RemotePendingCommitFeeSat } return 0 } type PendingChannelsResponse_ClosedChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pending channel to be closed Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` // The transaction id of the closing transaction ClosingTxid string `protobuf:"bytes,2,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` } func (x *PendingChannelsResponse_ClosedChannel) Reset() { *x = PendingChannelsResponse_ClosedChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[194] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_ClosedChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_ClosedChannel) ProtoMessage() {} func (x *PendingChannelsResponse_ClosedChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[194] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_ClosedChannel.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_ClosedChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 4} } func (x *PendingChannelsResponse_ClosedChannel) GetChannel() *PendingChannelsResponse_PendingChannel { if x != nil { return x.Channel } return nil } func (x *PendingChannelsResponse_ClosedChannel) GetClosingTxid() string { if x != nil { return x.ClosingTxid } return "" } type PendingChannelsResponse_ForceClosedChannel struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields // The pending channel to be force closed Channel *PendingChannelsResponse_PendingChannel `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty"` // The transaction id of the closing transaction ClosingTxid string `protobuf:"bytes,2,opt,name=closing_txid,json=closingTxid,proto3" json:"closing_txid,omitempty"` // The balance in satoshis encumbered in this pending channel LimboBalance int64 `protobuf:"varint,3,opt,name=limbo_balance,json=limboBalance,proto3" json:"limbo_balance,omitempty"` // The height at which funds can be swept into the wallet MaturityHeight uint32 `protobuf:"varint,4,opt,name=maturity_height,json=maturityHeight,proto3" json:"maturity_height,omitempty"` // //Remaining # of blocks until the commitment output can be swept. //Negative values indicate how many blocks have passed since becoming //mature. BlocksTilMaturity int32 `protobuf:"varint,5,opt,name=blocks_til_maturity,json=blocksTilMaturity,proto3" json:"blocks_til_maturity,omitempty"` // The total value of funds successfully recovered from this channel RecoveredBalance int64 `protobuf:"varint,6,opt,name=recovered_balance,json=recoveredBalance,proto3" json:"recovered_balance,omitempty"` PendingHtlcs []*PendingHTLC `protobuf:"bytes,8,rep,name=pending_htlcs,json=pendingHtlcs,proto3" json:"pending_htlcs,omitempty"` Anchor PendingChannelsResponse_ForceClosedChannel_AnchorState `protobuf:"varint,9,opt,name=anchor,proto3,enum=lnrpc.PendingChannelsResponse_ForceClosedChannel_AnchorState" json:"anchor,omitempty"` } func (x *PendingChannelsResponse_ForceClosedChannel) Reset() { *x = PendingChannelsResponse_ForceClosedChannel{} if protoimpl.UnsafeEnabled { mi := &file_lightning_proto_msgTypes[195] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } func (x *PendingChannelsResponse_ForceClosedChannel) String() string { return protoimpl.X.MessageStringOf(x) } func (*PendingChannelsResponse_ForceClosedChannel) ProtoMessage() {} func (x *PendingChannelsResponse_ForceClosedChannel) ProtoReflect() protoreflect.Message { mi := &file_lightning_proto_msgTypes[195] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) } return ms } return mi.MessageOf(x) } // Deprecated: Use PendingChannelsResponse_ForceClosedChannel.ProtoReflect.Descriptor instead. func (*PendingChannelsResponse_ForceClosedChannel) Descriptor() ([]byte, []int) { return file_lightning_proto_rawDescGZIP(), []int{79, 5} } func (x *PendingChannelsResponse_ForceClosedChannel) GetChannel() *PendingChannelsResponse_PendingChannel { if x != nil { return x.Channel } return nil } func (x *PendingChannelsResponse_ForceClosedChannel) GetClosingTxid() string { if x != nil { return x.ClosingTxid } return "" } func (x *PendingChannelsResponse_ForceClosedChannel) GetLimboBalance() int64 { if x != nil { return x.LimboBalance } return 0 } func (x *PendingChannelsResponse_ForceClosedChannel) GetMaturityHeight() uint32 { if x != nil { return x.MaturityHeight } return 0 } func (x *PendingChannelsResponse_ForceClosedChannel) GetBlocksTilMaturity() int32 { if x != nil { return x.BlocksTilMaturity } return 0 } func (x *PendingChannelsResponse_ForceClosedChannel) GetRecoveredBalance() int64 { if x != nil { return x.RecoveredBalance } return 0 } func (x *PendingChannelsResponse_ForceClosedChannel) GetPendingHtlcs() []*PendingHTLC { if x != nil { return x.PendingHtlcs } return nil } func (x *PendingChannelsResponse_ForceClosedChannel) GetAnchor() PendingChannelsResponse_ForceClosedChannel_AnchorState { if x != nil { return x.Anchor } return PendingChannelsResponse_ForceClosedChannel_LIMBO } var File_lightning_proto protoreflect.FileDescriptor var file_lightning_proto_rawDesc = []byte{ 0x0a, 0x0f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x22, 0x20, 0x0a, 0x1e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x4b, 0x0a, 0x0d, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x56, 0x0a, 0x18, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x1b, 0x0a, 0x19, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xe6, 0x01, 0x0a, 0x04, 0x55, 0x74, 0x78, 0x6f, 0x12, 0x35, 0x0a, 0x0c, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x61, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x6b, 0x5f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x6b, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x2b, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xc6, 0x02, 0x0a, 0x0b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x78, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x78, 0x48, 0x61, 0x73, 0x68, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x6e, 0x75, 0x6d, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x46, 0x65, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x1c, 0x0a, 0x0a, 0x72, 0x61, 0x77, 0x5f, 0x74, 0x78, 0x5f, 0x68, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x61, 0x77, 0x54, 0x78, 0x48, 0x65, 0x78, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x74, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x4c, 0x0a, 0x12, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x36, 0x0a, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x68, 0x0a, 0x08, 0x46, 0x65, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x16, 0x0a, 0x05, 0x66, 0x69, 0x78, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x05, 0x66, 0x69, 0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0a, 0x66, 0x69, 0x78, 0x65, 0x64, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x09, 0x66, 0x69, 0x78, 0x65, 0x64, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1a, 0x0a, 0x07, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x07, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x22, 0xea, 0x05, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x64, 0x65, 0x73, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x6d, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x61, 0x6d, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x61, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x32, 0x0a, 0x13, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x11, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x43, 0x6c, 0x74, 0x76, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x09, 0x66, 0x65, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x08, 0x66, 0x65, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2c, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x6f, 0x70, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x70, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x63, 0x6c, 0x74, 0x76, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x59, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x44, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x64, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x65, 0x6c, 0x66, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x65, 0x6c, 0x66, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x36, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x69, 0x74, 0x52, 0x0c, 0x64, 0x65, 0x73, 0x74, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x1a, 0x44, 0x0a, 0x16, 0x44, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb4, 0x01, 0x0a, 0x0c, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x31, 0x0a, 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x95, 0x01, 0x0a, 0x12, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x32, 0x0a, 0x13, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x11, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x22, 0x0a, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x9a, 0x04, 0x0a, 0x14, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x6d, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x6d, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x61, 0x6d, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x70, 0x75, 0x73, 0x68, 0x41, 0x6d, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x75, 0x73, 0x74, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x64, 0x75, 0x73, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x2d, 0x0a, 0x13, 0x6d, 0x61, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x69, 0x6e, 0x5f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x49, 0x6e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x12, 0x1c, 0x0a, 0x0a, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6b, 0x77, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x66, 0x65, 0x65, 0x50, 0x65, 0x72, 0x4b, 0x77, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x63, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0xf3, 0x02, 0x0a, 0x15, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x75, 0x70, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x75, 0x70, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x63, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x69, 0x6e, 0x5f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x69, 0x6e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x4d, 0x61, 0x78, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x6d, 0x61, 0x78, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x48, 0x74, 0x6c, 0x63, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1e, 0x0a, 0x0b, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x69, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x49, 0x6e, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x69, 0x6e, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x5f, 0x64, 0x65, 0x70, 0x74, 0x68, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6d, 0x69, 0x6e, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x44, 0x65, 0x70, 0x74, 0x68, 0x22, 0x9d, 0x01, 0x0a, 0x0c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x2e, 0x0a, 0x12, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x10, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x10, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0e, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x53, 0x74, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x0e, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x22, 0x67, 0x0a, 0x08, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x78, 0x69, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x74, 0x78, 0x69, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x78, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x78, 0x69, 0x64, 0x53, 0x74, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x3e, 0x0a, 0x10, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x22, 0x91, 0x02, 0x0a, 0x12, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4f, 0x0a, 0x0c, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x55, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x1a, 0x3f, 0x0a, 0x11, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x87, 0x01, 0x0a, 0x13, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x66, 0x65, 0x65, 0x53, 0x61, 0x74, 0x12, 0x33, 0x0a, 0x14, 0x66, 0x65, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x11, 0x66, 0x65, 0x65, 0x72, 0x61, 0x74, 0x65, 0x53, 0x61, 0x74, 0x50, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x22, 0xeb, 0x02, 0x0a, 0x0f, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4c, 0x0a, 0x0c, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x55, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x1a, 0x3f, 0x0a, 0x11, 0x41, 0x64, 0x64, 0x72, 0x54, 0x6f, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x26, 0x0a, 0x10, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x78, 0x69, 0x64, 0x22, 0xa4, 0x02, 0x0a, 0x10, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x64, 0x64, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x61, 0x6c, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x65, 0x6e, 0x64, 0x41, 0x6c, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x55, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x22, 0x27, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x78, 0x69, 0x64, 0x22, 0x68, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x38, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x05, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x74, 0x78, 0x6f, 0x52, 0x05, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x22, 0x55, 0x0a, 0x11, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x2e, 0x0a, 0x12, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x22, 0x47, 0x0a, 0x12, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x48, 0x61, 0x73, 0x68, 0x22, 0x33, 0x0a, 0x13, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x46, 0x0a, 0x14, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x73, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6d, 0x73, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x45, 0x0a, 0x15, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x22, 0x6f, 0x0a, 0x12, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x04, 0x61, 0x64, 0x64, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x72, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x70, 0x65, 0x72, 0x6d, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x15, 0x0a, 0x13, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x0a, 0x15, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x22, 0x18, 0x0a, 0x16, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x86, 0x02, 0x0a, 0x04, 0x48, 0x54, 0x4c, 0x43, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x68, 0x61, 0x73, 0x68, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x2b, 0x0a, 0x11, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x68, 0x74, 0x6c, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x2d, 0x0a, 0x12, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x32, 0x0a, 0x15, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x74, 0x6c, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x84, 0x02, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x63, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x63, 0x68, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x64, 0x75, 0x73, 0x74, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x64, 0x75, 0x73, 0x74, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x53, 0x61, 0x74, 0x12, 0x2f, 0x0a, 0x14, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x6d, 0x61, 0x78, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x6d, 0x61, 0x78, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x22, 0xd7, 0x09, 0x0a, 0x07, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1c, 0x0a, 0x0a, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6b, 0x77, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x65, 0x65, 0x50, 0x65, 0x72, 0x4b, 0x77, 0x12, 0x2b, 0x0a, 0x11, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x5f, 0x73, 0x65, 0x6e, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x12, 0x36, 0x0a, 0x17, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x6e, 0x75, 0x6d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x54, 0x4c, 0x43, 0x52, 0x0c, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x1f, 0x0a, 0x09, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x63, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x13, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x63, 0x68, 0x61, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x37, 0x0a, 0x16, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x13, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x39, 0x0a, 0x17, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x15, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x14, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x2e, 0x0a, 0x11, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x16, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0f, 0x73, 0x74, 0x61, 0x74, 0x69, 0x63, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x18, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x75, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x70, 0x75, 0x73, 0x68, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x61, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x68, 0x61, 0x77, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x74, 0x68, 0x61, 0x77, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x46, 0x0a, 0x11, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x10, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x48, 0x0a, 0x12, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x52, 0x11, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x22, 0xb3, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x22, 0x42, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0xd8, 0x05, 0x0a, 0x13, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x26, 0x0a, 0x0f, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x48, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x45, 0x0a, 0x0a, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x37, 0x0a, 0x0e, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x39, 0x0a, 0x0f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x0e, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x33, 0x0a, 0x0b, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x8a, 0x01, 0x0a, 0x0b, 0x43, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x43, 0x4f, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x49, 0x56, 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x4c, 0x4f, 0x43, 0x41, 0x4c, 0x5f, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x10, 0x02, 0x12, 0x10, 0x0a, 0x0c, 0x42, 0x52, 0x45, 0x41, 0x43, 0x48, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x46, 0x55, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x04, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x42, 0x41, 0x4e, 0x44, 0x4f, 0x4e, 0x45, 0x44, 0x10, 0x05, 0x22, 0xeb, 0x01, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x32, 0x0a, 0x07, 0x6f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x52, 0x07, 0x6f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x12, 0x2b, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x77, 0x65, 0x65, 0x70, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x77, 0x65, 0x65, 0x70, 0x54, 0x78, 0x69, 0x64, 0x22, 0xde, 0x01, 0x0a, 0x15, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x72, 0x65, 0x61, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x62, 0x72, 0x65, 0x61, 0x63, 0x68, 0x12, 0x29, 0x0a, 0x10, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x65, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x64, 0x22, 0x50, 0x0a, 0x16, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0x8b, 0x05, 0x0a, 0x04, 0x50, 0x65, 0x65, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x73, 0x65, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x62, 0x79, 0x74, 0x65, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x79, 0x74, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x63, 0x76, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x62, 0x79, 0x74, 0x65, 0x73, 0x52, 0x65, 0x63, 0x76, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x61, 0x74, 0x5f, 0x73, 0x65, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x61, 0x74, 0x53, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x61, 0x74, 0x5f, 0x72, 0x65, 0x63, 0x76, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 0x61, 0x74, 0x52, 0x65, 0x63, 0x76, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x70, 0x69, 0x6e, 0x67, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x31, 0x0a, 0x09, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x06, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x65, 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x06, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x6c, 0x61, 0x70, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x6c, 0x61, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x66, 0x6c, 0x61, 0x70, 0x5f, 0x6e, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6c, 0x61, 0x73, 0x74, 0x46, 0x6c, 0x61, 0x70, 0x4e, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x50, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x50, 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x41, 0x53, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x49, 0x4e, 0x4e, 0x45, 0x44, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x10, 0x03, 0x22, 0x46, 0x0a, 0x10, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x65, 0x64, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x35, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x36, 0x0a, 0x11, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x05, 0x70, 0x65, 0x65, 0x72, 0x73, 0x22, 0x17, 0x0a, 0x15, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x84, 0x01, 0x0a, 0x09, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x2e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2e, 0x0a, 0x09, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x4f, 0x4e, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x4f, 0x46, 0x46, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x01, 0x22, 0x10, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x87, 0x06, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x27, 0x0a, 0x0f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x12, 0x30, 0x0a, 0x14, 0x6e, 0x75, 0x6d, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x6e, 0x75, 0x6d, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x6e, 0x75, 0x6d, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x6e, 0x75, 0x6d, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x32, 0x0a, 0x15, 0x6e, 0x75, 0x6d, 0x5f, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x6e, 0x75, 0x6d, 0x49, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x75, 0x6d, 0x5f, 0x70, 0x65, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x6e, 0x75, 0x6d, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x12, 0x32, 0x0a, 0x15, 0x62, 0x65, 0x73, 0x74, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x62, 0x65, 0x73, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x54, 0x6f, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x26, 0x0a, 0x0f, 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x5f, 0x74, 0x6f, 0x5f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x54, 0x6f, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x1c, 0x0a, 0x07, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x74, 0x65, 0x73, 0x74, 0x6e, 0x65, 0x74, 0x12, 0x24, 0x0a, 0x06, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x52, 0x06, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x75, 0x72, 0x69, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x75, 0x72, 0x69, 0x73, 0x12, 0x40, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x13, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x4a, 0x04, 0x08, 0x0b, 0x10, 0x0c, 0x22, 0x18, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x87, 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x66, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x37, 0x0a, 0x05, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x22, 0x7a, 0x0a, 0x12, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x53, 0x68, 0x61, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x75, 0x6d, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x5f, 0x6c, 0x65, 0x66, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x4c, 0x65, 0x66, 0x74, 0x22, 0x4d, 0x0a, 0x11, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x38, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x51, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x22, 0xfb, 0x01, 0x0a, 0x13, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x24, 0x0a, 0x0c, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x65, 0x6c, 0x69, 0x76, 0x65, 0x72, 0x79, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x22, 0x96, 0x01, 0x0a, 0x11, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x3b, 0x0a, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x3a, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x42, 0x08, 0x0a, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x22, 0x46, 0x0a, 0x0d, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x74, 0x78, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x79, 0x0a, 0x13, 0x52, 0x65, 0x61, 0x64, 0x79, 0x46, 0x6f, 0x72, 0x50, 0x73, 0x62, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x73, 0x62, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x73, 0x62, 0x74, 0x22, 0xf3, 0x01, 0x0a, 0x17, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x33, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x55, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0xf5, 0x02, 0x0a, 0x10, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x70, 0x75, 0x73, 0x68, 0x53, 0x61, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0x5b, 0x0a, 0x18, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x10, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0x80, 0x06, 0x0a, 0x12, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x12, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x10, 0x6e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x70, 0x75, 0x73, 0x68, 0x53, 0x61, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x24, 0x0a, 0x0c, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x73, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x73, 0x76, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6d, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x55, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x35, 0x0a, 0x0c, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x68, 0x69, 0x6d, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x52, 0x0b, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x12, 0x43, 0x0a, 0x1f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x69, 0x6e, 0x5f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1a, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4d, 0x61, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x49, 0x6e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4d, 0x61, 0x78, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x73, 0x76, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x43, 0x73, 0x76, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x22, 0xf3, 0x01, 0x0a, 0x10, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x39, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x12, 0x37, 0x0a, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4f, 0x70, 0x65, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x4f, 0x70, 0x65, 0x6e, 0x12, 0x39, 0x0a, 0x09, 0x70, 0x73, 0x62, 0x74, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x79, 0x46, 0x6f, 0x72, 0x50, 0x73, 0x62, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x00, 0x52, 0x08, 0x70, 0x73, 0x62, 0x74, 0x46, 0x75, 0x6e, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x42, 0x08, 0x0a, 0x06, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x22, 0x48, 0x0a, 0x0a, 0x4b, 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x5f, 0x0a, 0x0d, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x61, 0x77, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x61, 0x77, 0x4b, 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x07, 0x6b, 0x65, 0x79, 0x5f, 0x6c, 0x6f, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x06, 0x6b, 0x65, 0x79, 0x4c, 0x6f, 0x63, 0x22, 0xf0, 0x01, 0x0a, 0x0d, 0x43, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x6d, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x61, 0x6d, 0x74, 0x12, 0x32, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x09, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x08, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x68, 0x61, 0x77, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x74, 0x68, 0x61, 0x77, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x6e, 0x0a, 0x08, 0x50, 0x73, 0x62, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x61, 0x73, 0x65, 0x50, 0x73, 0x62, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x6f, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6e, 0x6f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x22, 0x85, 0x01, 0x0a, 0x0b, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x68, 0x69, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x12, 0x2e, 0x0a, 0x09, 0x70, 0x73, 0x62, 0x74, 0x5f, 0x73, 0x68, 0x69, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x73, 0x62, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x48, 0x00, 0x52, 0x08, 0x70, 0x73, 0x62, 0x74, 0x53, 0x68, 0x69, 0x6d, 0x42, 0x06, 0x0a, 0x04, 0x73, 0x68, 0x69, 0x6d, 0x22, 0x3b, 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x22, 0x81, 0x01, 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x73, 0x62, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x50, 0x73, 0x62, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x73, 0x6b, 0x69, 0x70, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x22, 0x80, 0x01, 0x0a, 0x13, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x73, 0x62, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x73, 0x62, 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0c, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x61, 0x77, 0x5f, 0x74, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x52, 0x61, 0x77, 0x54, 0x78, 0x22, 0x99, 0x02, 0x0a, 0x14, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x12, 0x39, 0x0a, 0x0d, 0x73, 0x68, 0x69, 0x6d, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x68, 0x69, 0x6d, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x0b, 0x73, 0x68, 0x69, 0x6d, 0x5f, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x68, 0x69, 0x6d, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x12, 0x3b, 0x0a, 0x0b, 0x70, 0x73, 0x62, 0x74, 0x5f, 0x76, 0x65, 0x72, 0x69, 0x66, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x73, 0x62, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x73, 0x62, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x12, 0x41, 0x0a, 0x0d, 0x70, 0x73, 0x62, 0x74, 0x5f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x73, 0x62, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x73, 0x62, 0x74, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x42, 0x09, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x22, 0x16, 0x0a, 0x14, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x65, 0x70, 0x52, 0x65, 0x73, 0x70, 0x22, 0xcc, 0x01, 0x0a, 0x0b, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x54, 0x4c, 0x43, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x5f, 0x74, 0x69, 0x6c, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x54, 0x69, 0x6c, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x73, 0x74, 0x61, 0x67, 0x65, 0x22, 0x18, 0x0a, 0x16, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xb5, 0x12, 0x0a, 0x17, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x6c, 0x69, 0x6d, 0x62, 0x6f, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4c, 0x69, 0x6d, 0x62, 0x6f, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x65, 0x0a, 0x15, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x13, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x6a, 0x0a, 0x18, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x16, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x76, 0x0a, 0x1e, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x1b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x68, 0x0a, 0x16, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x57, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x14, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x1a, 0xd9, 0x03, 0x0a, 0x0e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x75, 0x62, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x16, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x13, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x35, 0x0a, 0x17, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x53, 0x61, 0x74, 0x12, 0x2e, 0x0a, 0x09, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x09, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x3e, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x15, 0x6e, 0x75, 0x6d, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x1a, 0xf0, 0x01, 0x0a, 0x12, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x47, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1c, 0x0a, 0x0a, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6b, 0x77, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x66, 0x65, 0x65, 0x50, 0x65, 0x72, 0x4b, 0x77, 0x1a, 0xd1, 0x01, 0x0a, 0x13, 0x57, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x47, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x69, 0x6d, 0x62, 0x6f, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x69, 0x6d, 0x62, 0x6f, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x4c, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0xa3, 0x02, 0x0a, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x54, 0x78, 0x69, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x54, 0x78, 0x69, 0x64, 0x12, 0x2e, 0x0a, 0x13, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x11, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x12, 0x2f, 0x0a, 0x14, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x65, 0x65, 0x53, 0x61, 0x74, 0x12, 0x31, 0x0a, 0x15, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x65, 0x65, 0x53, 0x61, 0x74, 0x12, 0x40, 0x0a, 0x1d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x65, 0x65, 0x53, 0x61, 0x74, 0x1a, 0x7b, 0x0a, 0x0d, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x47, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x1a, 0xee, 0x03, 0x0a, 0x12, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x47, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x69, 0x6e, 0x67, 0x54, 0x78, 0x69, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x69, 0x6d, 0x62, 0x6f, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x69, 0x6d, 0x62, 0x6f, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x5f, 0x74, 0x69, 0x6c, 0x5f, 0x6d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x54, 0x69, 0x6c, 0x4d, 0x61, 0x74, 0x75, 0x72, 0x69, 0x74, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x37, 0x0a, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x54, 0x4c, 0x43, 0x52, 0x0c, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x55, 0x0a, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x3d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x22, 0x31, 0x0a, 0x0b, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x4c, 0x49, 0x4d, 0x42, 0x4f, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x52, 0x45, 0x43, 0x4f, 0x56, 0x45, 0x52, 0x45, 0x44, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x4f, 0x53, 0x54, 0x10, 0x02, 0x22, 0x1a, 0x0a, 0x18, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xff, 0x04, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x33, 0x0a, 0x0c, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x43, 0x0a, 0x0e, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x75, 0x6d, 0x6d, 0x61, 0x72, 0x79, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x3c, 0x0a, 0x0e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0d, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x40, 0x0a, 0x10, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0f, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x48, 0x0a, 0x14, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x12, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x4b, 0x0a, 0x16, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x14, 0x66, 0x75, 0x6c, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x92, 0x01, 0x0a, 0x0a, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x4f, 0x50, 0x45, 0x4e, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x49, 0x4e, 0x41, 0x43, 0x54, 0x49, 0x56, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x5f, 0x4f, 0x50, 0x45, 0x4e, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x04, 0x12, 0x1a, 0x0a, 0x16, 0x46, 0x55, 0x4c, 0x4c, 0x59, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x4c, 0x56, 0x45, 0x44, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x10, 0x05, 0x42, 0x09, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x22, 0x74, 0x0a, 0x14, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x16, 0x0a, 0x14, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd5, 0x02, 0x0a, 0x15, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x75, 0x6e, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x72, 0x6d, 0x65, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x59, 0x0a, 0x0f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x1a, 0x5e, 0x0a, 0x13, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x2e, 0x0a, 0x06, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x73, 0x61, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x6d, 0x73, 0x61, 0x74, 0x22, 0x17, 0x0a, 0x15, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x80, 0x04, 0x0a, 0x16, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x34, 0x0a, 0x14, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x12, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x32, 0x0a, 0x0d, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x0c, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x34, 0x0a, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x0d, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x45, 0x0a, 0x17, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x15, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x47, 0x0a, 0x18, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x16, 0x75, 0x6e, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x4a, 0x0a, 0x1a, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x17, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x4c, 0x0a, 0x1b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x18, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x70, 0x65, 0x6e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x22, 0xae, 0x06, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x6d, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x61, 0x6d, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x61, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x43, 0x6c, 0x74, 0x76, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x2c, 0x0a, 0x09, 0x66, 0x65, 0x65, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x52, 0x08, 0x66, 0x65, 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x5f, 0x65, 0x64, 0x67, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x64, 0x67, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x45, 0x64, 0x67, 0x65, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x2e, 0x0a, 0x13, 0x75, 0x73, 0x65, 0x5f, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x75, 0x73, 0x65, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x12, 0x34, 0x0a, 0x0d, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x69, 0x72, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x0c, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x64, 0x50, 0x61, 0x69, 0x72, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x63, 0x6c, 0x74, 0x76, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x60, 0x0a, 0x13, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x44, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x64, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x2c, 0x0a, 0x10, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x68, 0x6f, 0x70, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x70, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x0b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x36, 0x0a, 0x0d, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x69, 0x74, 0x52, 0x0c, 0x64, 0x65, 0x73, 0x74, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x44, 0x0a, 0x16, 0x44, 0x65, 0x73, 0x74, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x2e, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x50, 0x61, 0x69, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x22, 0x5d, 0x0a, 0x0b, 0x45, 0x64, 0x67, 0x65, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x21, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x22, 0x5e, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x06, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x50, 0x72, 0x6f, 0x62, 0x22, 0x91, 0x04, 0x0a, 0x03, 0x48, 0x6f, 0x70, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x27, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x28, 0x0a, 0x0e, 0x61, 0x6d, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x61, 0x6d, 0x74, 0x54, 0x6f, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x12, 0x14, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x2d, 0x0a, 0x13, 0x61, 0x6d, 0x74, 0x5f, 0x74, 0x6f, 0x5f, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x61, 0x6d, 0x74, 0x54, 0x6f, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x65, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6c, 0x76, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x74, 0x6c, 0x76, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x2f, 0x0a, 0x0a, 0x6d, 0x70, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x50, 0x50, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x09, 0x6d, 0x70, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x2f, 0x0a, 0x0a, 0x61, 0x6d, 0x70, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x4d, 0x50, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x52, 0x09, 0x61, 0x6d, 0x70, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x44, 0x0a, 0x0e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x0b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x6f, 0x70, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x1a, 0x40, 0x0a, 0x12, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x54, 0x0a, 0x09, 0x4d, 0x50, 0x50, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x22, 0x62, 0x0a, 0x09, 0x41, 0x4d, 0x50, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0xe1, 0x01, 0x0a, 0x05, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x54, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x21, 0x0a, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x46, 0x65, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x09, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x6d, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x6d, 0x74, 0x12, 0x1e, 0x0a, 0x04, 0x68, 0x6f, 0x70, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x6f, 0x70, 0x52, 0x04, 0x68, 0x6f, 0x70, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x46, 0x65, 0x65, 0x73, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x22, 0x55, 0x0a, 0x0f, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0xae, 0x01, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x28, 0x0a, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x6e, 0x6f, 0x64, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6e, 0x75, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x2e, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0xb4, 0x02, 0x0a, 0x0d, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x30, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x12, 0x3e, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x3b, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x61, 0x64, 0x64, 0x72, 0x22, 0x86, 0x02, 0x0a, 0x0d, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x12, 0x22, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x66, 0x65, 0x65, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x2d, 0x0a, 0x13, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x22, 0xbc, 0x02, 0x0a, 0x0b, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x12, 0x21, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x23, 0x0a, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0a, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x31, 0x5f, 0x70, 0x75, 0x62, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x31, 0x50, 0x75, 0x62, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x32, 0x5f, 0x70, 0x75, 0x62, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x32, 0x50, 0x75, 0x62, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x37, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x31, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x31, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x37, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x32, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x32, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x22, 0x46, 0x0a, 0x13, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2f, 0x0a, 0x13, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x75, 0x6e, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x55, 0x6e, 0x61, 0x6e, 0x6e, 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x64, 0x22, 0x64, 0x0a, 0x0c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x2a, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x05, 0x65, 0x64, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x52, 0x05, 0x65, 0x64, 0x67, 0x65, 0x73, 0x22, 0x41, 0x0a, 0x12, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x74, 0x79, 0x70, 0x65, 0x73, 0x22, 0xe1, 0x01, 0x0a, 0x13, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c, 0x0a, 0x16, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x42, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x15, 0x62, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x1a, 0x5c, 0x0a, 0x1a, 0x42, 0x65, 0x74, 0x77, 0x65, 0x65, 0x6e, 0x6e, 0x65, 0x73, 0x73, 0x43, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x28, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x4e, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6e, 0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x2e, 0x0a, 0x0f, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xd5, 0x03, 0x0a, 0x0b, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x72, 0x61, 0x70, 0x68, 0x5f, 0x64, 0x69, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x67, 0x72, 0x61, 0x70, 0x68, 0x44, 0x69, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x0e, 0x61, 0x76, 0x67, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0c, 0x61, 0x76, 0x67, 0x4f, 0x75, 0x74, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x6d, 0x61, 0x78, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x64, 0x65, 0x67, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6d, 0x61, 0x78, 0x4f, 0x75, 0x74, 0x44, 0x65, 0x67, 0x72, 0x65, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x75, 0x6d, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x6e, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6e, 0x75, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x61, 0x76, 0x67, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x61, 0x76, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6d, 0x69, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6d, 0x61, 0x78, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x35, 0x0a, 0x17, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x14, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x53, 0x69, 0x7a, 0x65, 0x53, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x7a, 0x6f, 0x6d, 0x62, 0x69, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x5a, 0x6f, 0x6d, 0x62, 0x69, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x73, 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x0a, 0x19, 0x47, 0x72, 0x61, 0x70, 0x68, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcd, 0x01, 0x0a, 0x13, 0x47, 0x72, 0x61, 0x70, 0x68, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x34, 0x0a, 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0b, 0x6e, 0x6f, 0x64, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x41, 0x0a, 0x0f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x73, 0x22, 0xef, 0x02, 0x0a, 0x0a, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x20, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x0f, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x12, 0x39, 0x0a, 0x0e, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x91, 0x02, 0x0a, 0x11, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x0a, 0x0e, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x0d, 0x72, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x22, 0xa7, 0x01, 0x0a, 0x13, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x32, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0xcf, 0x01, 0x0a, 0x07, 0x48, 0x6f, 0x70, 0x48, 0x69, 0x6e, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0d, 0x66, 0x65, 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x66, 0x65, 0x65, 0x42, 0x61, 0x73, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x3e, 0x0a, 0x1b, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x19, 0x66, 0x65, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x6f, 0x6e, 0x74, 0x68, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x63, 0x6c, 0x74, 0x76, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x22, 0x1e, 0x0a, 0x05, 0x53, 0x65, 0x74, 0x49, 0x44, 0x12, 0x15, 0x0a, 0x06, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x73, 0x65, 0x74, 0x49, 0x64, 0x22, 0x38, 0x0a, 0x09, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x12, 0x2b, 0x0a, 0x09, 0x68, 0x6f, 0x70, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x6f, 0x70, 0x48, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x68, 0x6f, 0x70, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x22, 0xa8, 0x01, 0x0a, 0x0f, 0x41, 0x4d, 0x50, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x61, 0x6d, 0x74, 0x5f, 0x70, 0x61, 0x69, 0x64, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x61, 0x6d, 0x74, 0x50, 0x61, 0x69, 0x64, 0x4d, 0x73, 0x61, 0x74, 0x22, 0xc3, 0x09, 0x0a, 0x07, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x65, 0x6d, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, 0x65, 0x6d, 0x6f, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x50, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x48, 0x61, 0x73, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x17, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1c, 0x0a, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x44, 0x61, 0x74, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x41, 0x64, 0x64, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x63, 0x6c, 0x74, 0x76, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x31, 0x0a, 0x0b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x10, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x61, 0x64, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x11, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1d, 0x0a, 0x08, 0x61, 0x6d, 0x74, 0x5f, 0x70, 0x61, 0x69, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x07, 0x61, 0x6d, 0x74, 0x50, 0x61, 0x69, 0x64, 0x12, 0x20, 0x0a, 0x0c, 0x61, 0x6d, 0x74, 0x5f, 0x70, 0x61, 0x69, 0x64, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x13, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x61, 0x6d, 0x74, 0x50, 0x61, 0x69, 0x64, 0x53, 0x61, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x61, 0x6d, 0x74, 0x5f, 0x70, 0x61, 0x69, 0x64, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x61, 0x6d, 0x74, 0x50, 0x61, 0x69, 0x64, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x31, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x28, 0x0a, 0x05, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x16, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x52, 0x05, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x65, 0x6e, 0x64, 0x18, 0x19, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x4b, 0x65, 0x79, 0x73, 0x65, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x12, 0x15, 0x0a, 0x06, 0x69, 0x73, 0x5f, 0x61, 0x6d, 0x70, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x69, 0x73, 0x41, 0x6d, 0x70, 0x12, 0x4f, 0x0a, 0x11, 0x61, 0x6d, 0x70, 0x5f, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x1c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x2e, 0x41, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x61, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x5a, 0x0a, 0x14, 0x41, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2c, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x4d, 0x50, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x41, 0x0a, 0x0c, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x4f, 0x50, 0x45, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x45, 0x54, 0x54, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xfc, 0x03, 0x0a, 0x0b, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x68, 0x74, 0x6c, 0x63, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x19, 0x0a, 0x08, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x61, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2d, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x4c, 0x0a, 0x0e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x2b, 0x0a, 0x12, 0x6d, 0x70, 0x70, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x6d, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x6d, 0x70, 0x70, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x6d, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1c, 0x0a, 0x03, 0x61, 0x6d, 0x70, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x4d, 0x50, 0x52, 0x03, 0x61, 0x6d, 0x70, 0x1a, 0x40, 0x0a, 0x12, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x8c, 0x01, 0x0a, 0x03, 0x41, 0x4d, 0x50, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x22, 0x94, 0x01, 0x0a, 0x12, 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x48, 0x61, 0x73, 0x68, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x10, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x61, 0x64, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x22, 0x46, 0x0a, 0x0b, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x20, 0x0a, 0x0a, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x72, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x48, 0x61, 0x73, 0x68, 0x22, 0xa0, 0x01, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x4d, 0x61, 0x78, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x22, 0x9b, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x08, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x08, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x66, 0x69, 0x72, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x55, 0x0a, 0x13, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09, 0x61, 0x64, 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x61, 0x64, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x65, 0x74, 0x74, 0x6c, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x8a, 0x05, 0x0a, 0x07, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x27, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x42, 0x02, 0x18, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x53, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x34, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x66, 0x65, 0x65, 0x53, 0x61, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x65, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6e, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x12, 0x28, 0x0a, 0x05, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x54, 0x4c, 0x43, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x52, 0x05, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x42, 0x0a, 0x0e, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, 0x0d, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x46, 0x0a, 0x0d, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x49, 0x4e, 0x5f, 0x46, 0x4c, 0x49, 0x47, 0x48, 0x54, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x22, 0xd5, 0x02, 0x0a, 0x0b, 0x48, 0x54, 0x4c, 0x43, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x49, 0x64, 0x12, 0x35, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x48, 0x54, 0x4c, 0x43, 0x41, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x2e, 0x48, 0x54, 0x4c, 0x43, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x22, 0x0a, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x61, 0x74, 0x74, 0x65, 0x6d, 0x70, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x12, 0x28, 0x0a, 0x07, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x07, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x70, 0x72, 0x65, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x22, 0x36, 0x0a, 0x0a, 0x48, 0x54, 0x4c, 0x43, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0d, 0x0a, 0x09, 0x49, 0x4e, 0x5f, 0x46, 0x4c, 0x49, 0x47, 0x48, 0x54, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x55, 0x43, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x10, 0x02, 0x22, 0xa6, 0x01, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x6d, 0x61, 0x78, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x64, 0x22, 0x9c, 0x01, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x08, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x10, 0x66, 0x69, 0x72, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x65, 0x0a, 0x14, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x22, 0x78, 0x0a, 0x18, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x14, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x12, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x48, 0x74, 0x6c, 0x63, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x22, 0x17, 0x0a, 0x15, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x0a, 0x19, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xbf, 0x01, 0x0a, 0x15, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x39, 0x0a, 0x19, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x68, 0x69, 0x6d, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x16, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x68, 0x69, 0x6d, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x31, 0x0a, 0x16, 0x69, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x5f, 0x77, 0x68, 0x61, 0x74, 0x5f, 0x69, 0x5f, 0x61, 0x6d, 0x5f, 0x64, 0x6f, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x69, 0x4b, 0x6e, 0x6f, 0x77, 0x57, 0x68, 0x61, 0x74, 0x49, 0x41, 0x6d, 0x44, 0x6f, 0x69, 0x6e, 0x67, 0x22, 0x18, 0x0a, 0x16, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x46, 0x0a, 0x11, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x68, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x73, 0x68, 0x6f, 0x77, 0x12, 0x1d, 0x0a, 0x0a, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x53, 0x70, 0x65, 0x63, 0x22, 0x35, 0x0a, 0x12, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x75, 0x62, 0x5f, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x75, 0x62, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x73, 0x22, 0x27, 0x0a, 0x0c, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x79, 0x52, 0x65, 0x71, 0x22, 0xb0, 0x04, 0x0a, 0x06, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x5f, 0x73, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6e, 0x75, 0x6d, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x41, 0x64, 0x64, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6c, 0x74, 0x76, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x31, 0x0a, 0x0b, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x48, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x75, 0x6d, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x37, 0x0a, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x66, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0x4b, 0x0a, 0x0d, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x59, 0x0a, 0x07, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x22, 0x12, 0x0a, 0x10, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xb3, 0x01, 0x0a, 0x10, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1e, 0x0a, 0x0b, 0x66, 0x65, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x6d, 0x69, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x66, 0x65, 0x65, 0x50, 0x65, 0x72, 0x4d, 0x69, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x22, 0xb5, 0x01, 0x0a, 0x11, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x66, 0x65, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x46, 0x65, 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x64, 0x61, 0x79, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x64, 0x61, 0x79, 0x46, 0x65, 0x65, 0x53, 0x75, 0x6d, 0x12, 0x20, 0x0a, 0x0c, 0x77, 0x65, 0x65, 0x6b, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x77, 0x65, 0x65, 0x6b, 0x46, 0x65, 0x65, 0x53, 0x75, 0x6d, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x6f, 0x6e, 0x74, 0x68, 0x46, 0x65, 0x65, 0x53, 0x75, 0x6d, 0x22, 0xd4, 0x02, 0x0a, 0x13, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x06, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x12, 0x34, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x66, 0x65, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x61, 0x78, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x61, 0x78, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x35, 0x0a, 0x17, 0x6d, 0x69, 0x6e, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x6d, 0x69, 0x6e, 0x48, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x42, 0x07, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x8c, 0x01, 0x0a, 0x0c, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x2b, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, 0x74, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x52, 0x0a, 0x14, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x0e, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x73, 0x22, 0x9d, 0x01, 0x0a, 0x18, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x24, 0x0a, 0x0e, 0x6e, 0x75, 0x6d, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x4d, 0x61, 0x78, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xbb, 0x02, 0x0a, 0x0f, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x18, 0x01, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x20, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x5f, 0x69, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x49, 0x6e, 0x12, 0x22, 0x0a, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x5f, 0x6f, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x4f, 0x75, 0x74, 0x12, 0x15, 0x0a, 0x06, 0x61, 0x6d, 0x74, 0x5f, 0x69, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x61, 0x6d, 0x74, 0x49, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x61, 0x6d, 0x74, 0x5f, 0x6f, 0x75, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x74, 0x4f, 0x75, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x65, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x66, 0x65, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x1e, 0x0a, 0x0b, 0x61, 0x6d, 0x74, 0x5f, 0x69, 0x6e, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x61, 0x6d, 0x74, 0x49, 0x6e, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x20, 0x0a, 0x0c, 0x61, 0x6d, 0x74, 0x5f, 0x6f, 0x75, 0x74, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x61, 0x6d, 0x74, 0x4f, 0x75, 0x74, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6e, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4e, 0x73, 0x22, 0x8c, 0x01, 0x0a, 0x19, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x11, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x10, 0x66, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x6c, 0x61, 0x73, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x50, 0x0a, 0x1a, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x32, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x64, 0x0a, 0x0d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x32, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x22, 0x73, 0x0a, 0x0f, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x34, 0x0a, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x22, 0x19, 0x0a, 0x17, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x9f, 0x01, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x45, 0x0a, 0x13, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x52, 0x11, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x42, 0x0a, 0x11, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x22, 0x49, 0x0a, 0x0e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x37, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x22, 0x8e, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x2c, 0x0a, 0x11, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x42, 0x08, 0x0a, 0x06, 0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x22, 0x17, 0x0a, 0x15, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1b, 0x0a, 0x19, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x1a, 0x0a, 0x18, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x44, 0x0a, 0x12, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xb0, 0x01, 0x0a, 0x13, 0x42, 0x61, 0x6b, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x64, 0x12, 0x3c, 0x0a, 0x1a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x32, 0x0a, 0x14, 0x42, 0x61, 0x6b, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x22, 0x18, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x3b, 0x0a, 0x17, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x20, 0x0a, 0x0c, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0a, 0x72, 0x6f, 0x6f, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x64, 0x73, 0x22, 0x39, 0x0a, 0x17, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x0b, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x64, 0x22, 0x34, 0x0a, 0x18, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x22, 0x55, 0x0a, 0x16, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x3b, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x18, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0xe4, 0x01, 0x0a, 0x17, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x64, 0x0a, 0x12, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5f, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x11, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x63, 0x0a, 0x16, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xb0, 0x08, 0x0a, 0x07, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x2e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x12, 0x3b, 0x0a, 0x0e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x68, 0x74, 0x6c, 0x63, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x6e, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x68, 0x61, 0x5f, 0x32, 0x35, 0x36, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x6f, 0x6e, 0x69, 0x6f, 0x6e, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6c, 0x74, 0x76, 0x5f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x6c, 0x74, 0x76, 0x45, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x5f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x66, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xef, 0x05, 0x0a, 0x0b, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x53, 0x45, 0x52, 0x56, 0x45, 0x44, 0x10, 0x00, 0x12, 0x28, 0x0a, 0x24, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x52, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x50, 0x41, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x44, 0x45, 0x54, 0x41, 0x49, 0x4c, 0x53, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x50, 0x41, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x41, 0x4d, 0x4f, 0x55, 0x4e, 0x54, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x46, 0x49, 0x4e, 0x41, 0x4c, 0x5f, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x43, 0x4c, 0x54, 0x56, 0x5f, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x46, 0x49, 0x4e, 0x41, 0x4c, 0x5f, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x48, 0x54, 0x4c, 0x43, 0x5f, 0x41, 0x4d, 0x4f, 0x55, 0x4e, 0x54, 0x10, 0x04, 0x12, 0x19, 0x0a, 0x15, 0x46, 0x49, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x53, 0x4f, 0x4f, 0x4e, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x52, 0x45, 0x41, 0x4c, 0x4d, 0x10, 0x06, 0x12, 0x13, 0x0a, 0x0f, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x53, 0x4f, 0x4f, 0x4e, 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x10, 0x08, 0x12, 0x16, 0x0a, 0x12, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x48, 0x4d, 0x41, 0x43, 0x10, 0x09, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x4b, 0x45, 0x59, 0x10, 0x0a, 0x12, 0x18, 0x0a, 0x14, 0x41, 0x4d, 0x4f, 0x55, 0x4e, 0x54, 0x5f, 0x42, 0x45, 0x4c, 0x4f, 0x57, 0x5f, 0x4d, 0x49, 0x4e, 0x49, 0x4d, 0x55, 0x4d, 0x10, 0x0b, 0x12, 0x14, 0x0a, 0x10, 0x46, 0x45, 0x45, 0x5f, 0x49, 0x4e, 0x53, 0x55, 0x46, 0x46, 0x49, 0x43, 0x49, 0x45, 0x4e, 0x54, 0x10, 0x0c, 0x12, 0x19, 0x0a, 0x15, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x43, 0x4c, 0x54, 0x56, 0x5f, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, 0x10, 0x0d, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x5f, 0x44, 0x49, 0x53, 0x41, 0x42, 0x4c, 0x45, 0x44, 0x10, 0x0e, 0x12, 0x1d, 0x0a, 0x19, 0x54, 0x45, 0x4d, 0x50, 0x4f, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x0f, 0x12, 0x21, 0x0a, 0x1d, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x10, 0x10, 0x12, 0x24, 0x0a, 0x20, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x5f, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4e, 0x47, 0x10, 0x11, 0x12, 0x15, 0x0a, 0x11, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x4e, 0x45, 0x58, 0x54, 0x5f, 0x50, 0x45, 0x45, 0x52, 0x10, 0x12, 0x12, 0x1a, 0x0a, 0x16, 0x54, 0x45, 0x4d, 0x50, 0x4f, 0x52, 0x41, 0x52, 0x59, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x13, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x45, 0x52, 0x4d, 0x41, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x4e, 0x4f, 0x44, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x14, 0x12, 0x1d, 0x0a, 0x19, 0x50, 0x45, 0x52, 0x4d, 0x41, 0x4e, 0x45, 0x4e, 0x54, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0x15, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, 0x5f, 0x54, 0x4f, 0x4f, 0x5f, 0x46, 0x41, 0x52, 0x10, 0x16, 0x12, 0x0f, 0x0a, 0x0b, 0x4d, 0x50, 0x50, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x4f, 0x55, 0x54, 0x10, 0x17, 0x12, 0x19, 0x0a, 0x15, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x50, 0x41, 0x59, 0x4c, 0x4f, 0x41, 0x44, 0x10, 0x18, 0x12, 0x15, 0x0a, 0x10, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0xe5, 0x07, 0x12, 0x14, 0x0a, 0x0f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0xe6, 0x07, 0x12, 0x17, 0x0a, 0x12, 0x55, 0x4e, 0x52, 0x45, 0x41, 0x44, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x10, 0xe7, 0x07, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x22, 0xb3, 0x03, 0x0a, 0x0d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x48, 0x61, 0x73, 0x68, 0x12, 0x1b, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x42, 0x02, 0x30, 0x01, 0x52, 0x06, 0x63, 0x68, 0x61, 0x6e, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x2a, 0x0a, 0x11, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x68, 0x74, 0x6c, 0x63, 0x4d, 0x69, 0x6e, 0x69, 0x6d, 0x75, 0x6d, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x62, 0x61, 0x73, 0x65, 0x46, 0x65, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x68, 0x74, 0x6c, 0x63, 0x5f, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x68, 0x74, 0x6c, 0x63, 0x4d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x4d, 0x73, 0x61, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x6f, 0x70, 0x61, 0x71, 0x75, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x65, 0x78, 0x74, 0x72, 0x61, 0x4f, 0x70, 0x61, 0x71, 0x75, 0x65, 0x44, 0x61, 0x74, 0x61, 0x22, 0x5d, 0x0a, 0x0a, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x03, 0x6f, 0x70, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x09, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x70, 0x52, 0x03, 0x6f, 0x70, 0x73, 0x22, 0x36, 0x0a, 0x02, 0x4f, 0x70, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x8e, 0x01, 0x0a, 0x13, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x4d, 0x61, 0x63, 0x50, 0x65, 0x72, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x22, 0x2c, 0x0a, 0x14, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x4d, 0x61, 0x63, 0x50, 0x65, 0x72, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x22, 0xcf, 0x02, 0x0a, 0x14, 0x52, 0x50, 0x43, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x61, 0x77, 0x5f, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x72, 0x61, 0x77, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x17, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x43, 0x61, 0x76, 0x65, 0x61, 0x74, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x34, 0x0a, 0x0b, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x61, 0x75, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x41, 0x75, 0x74, 0x68, 0x48, 0x00, 0x52, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x41, 0x75, 0x74, 0x68, 0x12, 0x2d, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2f, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x6d, 0x73, 0x67, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x6d, 0x73, 0x67, 0x49, 0x64, 0x42, 0x10, 0x0a, 0x0e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x34, 0x0a, 0x0a, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x41, 0x75, 0x74, 0x68, 0x12, 0x26, 0x0a, 0x0f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x46, 0x75, 0x6c, 0x6c, 0x55, 0x72, 0x69, 0x22, 0x90, 0x01, 0x0a, 0x0a, 0x52, 0x50, 0x43, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x5f, 0x66, 0x75, 0x6c, 0x6c, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x46, 0x75, 0x6c, 0x6c, 0x55, 0x72, 0x69, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x72, 0x70, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x70, 0x63, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x22, 0xc0, 0x01, 0x0a, 0x15, 0x52, 0x50, 0x43, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x0a, 0x72, 0x65, 0x66, 0x5f, 0x6d, 0x73, 0x67, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x72, 0x65, 0x66, 0x4d, 0x73, 0x67, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x08, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x08, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x36, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x46, 0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x48, 0x00, 0x52, 0x08, 0x66, 0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x42, 0x14, 0x0a, 0x12, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa6, 0x01, 0x0a, 0x16, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3d, 0x0a, 0x1b, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x6d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x76, 0x65, 0x61, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x18, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x43, 0x61, 0x76, 0x65, 0x61, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x72, 0x65, 0x61, 0x64, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x72, 0x65, 0x61, 0x64, 0x4f, 0x6e, 0x6c, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x8b, 0x01, 0x0a, 0x11, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x46, 0x65, 0x65, 0x64, 0x62, 0x61, 0x63, 0x6b, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x29, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x35, 0x0a, 0x16, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x15, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x2a, 0x7d, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x13, 0x57, 0x49, 0x54, 0x4e, 0x45, 0x53, 0x53, 0x5f, 0x50, 0x55, 0x42, 0x4b, 0x45, 0x59, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x4e, 0x45, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x50, 0x55, 0x42, 0x4b, 0x45, 0x59, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x10, 0x01, 0x12, 0x1e, 0x0a, 0x1a, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x57, 0x49, 0x54, 0x4e, 0x45, 0x53, 0x53, 0x5f, 0x50, 0x55, 0x42, 0x4b, 0x45, 0x59, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x10, 0x02, 0x12, 0x1d, 0x0a, 0x19, 0x55, 0x4e, 0x55, 0x53, 0x45, 0x44, 0x5f, 0x4e, 0x45, 0x53, 0x54, 0x45, 0x44, 0x5f, 0x50, 0x55, 0x42, 0x4b, 0x45, 0x59, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x10, 0x03, 0x2a, 0x78, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x17, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x54, 0x41, 0x54, 0x49, 0x43, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x4b, 0x45, 0x59, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x53, 0x10, 0x03, 0x12, 0x19, 0x0a, 0x15, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x5f, 0x45, 0x4e, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x44, 0x5f, 0x4c, 0x45, 0x41, 0x53, 0x45, 0x10, 0x04, 0x2a, 0x61, 0x0a, 0x09, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x6f, 0x72, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4c, 0x4f, 0x43, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x42, 0x4f, 0x54, 0x48, 0x10, 0x03, 0x2a, 0x60, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x43, 0x4f, 0x4d, 0x49, 0x4e, 0x47, 0x5f, 0x48, 0x54, 0x4c, 0x43, 0x10, 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x4f, 0x55, 0x54, 0x47, 0x4f, 0x49, 0x4e, 0x47, 0x5f, 0x48, 0x54, 0x4c, 0x43, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x10, 0x04, 0x2a, 0x71, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x63, 0x6f, 0x6d, 0x65, 0x12, 0x13, 0x0a, 0x0f, 0x4f, 0x55, 0x54, 0x43, 0x4f, 0x4d, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x4c, 0x41, 0x49, 0x4d, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x43, 0x4c, 0x41, 0x49, 0x4d, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0d, 0x0a, 0x09, 0x41, 0x42, 0x41, 0x4e, 0x44, 0x4f, 0x4e, 0x45, 0x44, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x49, 0x52, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x47, 0x45, 0x10, 0x04, 0x12, 0x0b, 0x0a, 0x07, 0x54, 0x49, 0x4d, 0x45, 0x4f, 0x55, 0x54, 0x10, 0x05, 0x2a, 0x39, 0x0a, 0x0e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x42, 0x45, 0x54, 0x57, 0x45, 0x45, 0x4e, 0x4e, 0x45, 0x53, 0x53, 0x5f, 0x43, 0x45, 0x4e, 0x54, 0x52, 0x41, 0x4c, 0x49, 0x54, 0x59, 0x10, 0x01, 0x2a, 0x3b, 0x0a, 0x10, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x48, 0x54, 0x4c, 0x43, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x45, 0x54, 0x54, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, 0x44, 0x10, 0x02, 0x2a, 0xd9, 0x01, 0x0a, 0x14, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x4f, 0x55, 0x54, 0x10, 0x01, 0x12, 0x1b, 0x0a, 0x17, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x4e, 0x4f, 0x5f, 0x52, 0x4f, 0x55, 0x54, 0x45, 0x10, 0x02, 0x12, 0x18, 0x0a, 0x14, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x03, 0x12, 0x2c, 0x0a, 0x28, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x49, 0x4e, 0x43, 0x4f, 0x52, 0x52, 0x45, 0x43, 0x54, 0x5f, 0x50, 0x41, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x44, 0x45, 0x54, 0x41, 0x49, 0x4c, 0x53, 0x10, 0x04, 0x12, 0x27, 0x0a, 0x23, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x52, 0x45, 0x41, 0x53, 0x4f, 0x4e, 0x5f, 0x49, 0x4e, 0x53, 0x55, 0x46, 0x46, 0x49, 0x43, 0x49, 0x45, 0x4e, 0x54, 0x5f, 0x42, 0x41, 0x4c, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x05, 0x2a, 0xcf, 0x04, 0x0a, 0x0a, 0x46, 0x65, 0x61, 0x74, 0x75, 0x72, 0x65, 0x42, 0x69, 0x74, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x41, 0x54, 0x41, 0x4c, 0x4f, 0x53, 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x45, 0x43, 0x54, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x41, 0x54, 0x41, 0x4c, 0x4f, 0x53, 0x53, 0x5f, 0x50, 0x52, 0x4f, 0x54, 0x45, 0x43, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x49, 0x4e, 0x49, 0x54, 0x49, 0x41, 0x4c, 0x5f, 0x52, 0x4f, 0x55, 0x49, 0x4e, 0x47, 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x55, 0x50, 0x46, 0x52, 0x4f, 0x4e, 0x54, 0x5f, 0x53, 0x48, 0x55, 0x54, 0x44, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x04, 0x12, 0x1f, 0x0a, 0x1b, 0x55, 0x50, 0x46, 0x52, 0x4f, 0x4e, 0x54, 0x5f, 0x53, 0x48, 0x55, 0x54, 0x44, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, 0x47, 0x4f, 0x53, 0x53, 0x49, 0x50, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x49, 0x45, 0x53, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x06, 0x12, 0x16, 0x0a, 0x12, 0x47, 0x4f, 0x53, 0x53, 0x49, 0x50, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x49, 0x45, 0x53, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x07, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x4c, 0x56, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x08, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x4c, 0x56, 0x5f, 0x4f, 0x4e, 0x49, 0x4f, 0x4e, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x09, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x58, 0x54, 0x5f, 0x47, 0x4f, 0x53, 0x53, 0x49, 0x50, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x49, 0x45, 0x53, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x0a, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x58, 0x54, 0x5f, 0x47, 0x4f, 0x53, 0x53, 0x49, 0x50, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x49, 0x45, 0x53, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x0b, 0x12, 0x19, 0x0a, 0x15, 0x53, 0x54, 0x41, 0x54, 0x49, 0x43, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x0c, 0x12, 0x19, 0x0a, 0x15, 0x53, 0x54, 0x41, 0x54, 0x49, 0x43, 0x5f, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x0d, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x41, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x0e, 0x12, 0x14, 0x0a, 0x10, 0x50, 0x41, 0x59, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x52, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x0f, 0x12, 0x0b, 0x0a, 0x07, 0x4d, 0x50, 0x50, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x10, 0x12, 0x0b, 0x0a, 0x07, 0x4d, 0x50, 0x50, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x11, 0x12, 0x16, 0x0a, 0x12, 0x57, 0x55, 0x4d, 0x42, 0x4f, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x53, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x12, 0x12, 0x16, 0x0a, 0x12, 0x57, 0x55, 0x4d, 0x42, 0x4f, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x4e, 0x45, 0x4c, 0x53, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x13, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x53, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x14, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x53, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x15, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x53, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x5f, 0x46, 0x45, 0x45, 0x5f, 0x48, 0x54, 0x4c, 0x43, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x16, 0x12, 0x1d, 0x0a, 0x19, 0x41, 0x4e, 0x43, 0x48, 0x4f, 0x52, 0x53, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x5f, 0x46, 0x45, 0x45, 0x5f, 0x48, 0x54, 0x4c, 0x43, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x17, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x4d, 0x50, 0x5f, 0x52, 0x45, 0x51, 0x10, 0x1e, 0x12, 0x0b, 0x0a, 0x07, 0x41, 0x4d, 0x50, 0x5f, 0x4f, 0x50, 0x54, 0x10, 0x1f, 0x2a, 0xac, 0x01, 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x46, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x02, 0x12, 0x1f, 0x0a, 0x1b, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x10, 0x03, 0x12, 0x24, 0x0a, 0x20, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x55, 0x52, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x50, 0x41, 0x52, 0x41, 0x4d, 0x45, 0x54, 0x45, 0x52, 0x10, 0x04, 0x32, 0xc9, 0x25, 0x0a, 0x09, 0x4c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x4a, 0x0a, 0x0d, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x0e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4b, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x44, 0x0a, 0x0b, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x73, 0x74, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x46, 0x65, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x12, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x6e, 0x73, 0x70, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x30, 0x01, 0x12, 0x3b, 0x0a, 0x08, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x12, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x61, 0x6e, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x0a, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x77, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x44, 0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4d, 0x0a, 0x0e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x50, 0x65, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x09, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x13, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x10, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x12, 0x38, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x15, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x30, 0x01, 0x12, 0x4d, 0x0a, 0x0e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x41, 0x0a, 0x0f, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x43, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x70, 0x65, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x30, 0x01, 0x12, 0x53, 0x0a, 0x10, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4f, 0x70, 0x65, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x10, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x65, 0x70, 0x12, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x53, 0x74, 0x65, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x50, 0x0a, 0x0f, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x28, 0x01, 0x30, 0x01, 0x12, 0x46, 0x0a, 0x0c, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x30, 0x01, 0x12, 0x4d, 0x0a, 0x0e, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x28, 0x01, 0x30, 0x01, 0x12, 0x3a, 0x0a, 0x0f, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x12, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x88, 0x02, 0x01, 0x28, 0x01, 0x30, 0x01, 0x12, 0x41, 0x0a, 0x0f, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x54, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x37, 0x0a, 0x0a, 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x0d, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x1a, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x41, 0x0a, 0x11, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x73, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x30, 0x01, 0x12, 0x32, 0x0a, 0x0c, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x12, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x1a, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x12, 0x47, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x11, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x6c, 0x6c, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x0d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x47, 0x72, 0x61, 0x70, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x47, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x39, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x64, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x44, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x35, 0x0a, 0x0a, 0x53, 0x74, 0x6f, 0x70, 0x44, 0x61, 0x65, 0x6d, 0x6f, 0x6e, 0x12, 0x12, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x15, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x47, 0x72, 0x61, 0x70, 0x68, 0x12, 0x20, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x61, 0x70, 0x68, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x61, 0x70, 0x68, 0x54, 0x6f, 0x70, 0x6f, 0x6c, 0x6f, 0x67, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x30, 0x01, 0x12, 0x41, 0x0a, 0x0a, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x09, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x17, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x65, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x11, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x13, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x21, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x54, 0x0a, 0x17, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x41, 0x6c, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x12, 0x4e, 0x0a, 0x10, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x12, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x1a, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x15, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x17, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x73, 0x12, 0x20, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x42, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x30, 0x01, 0x12, 0x47, 0x0a, 0x0c, 0x42, 0x61, 0x6b, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x6b, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x6b, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x18, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x4d, 0x61, 0x63, 0x61, 0x72, 0x6f, 0x6f, 0x6e, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1a, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x4d, 0x61, 0x63, 0x50, 0x65, 0x72, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x4d, 0x61, 0x63, 0x50, 0x65, 0x72, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x15, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x50, 0x43, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x12, 0x1c, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x1a, 0x1b, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x50, 0x43, 0x4d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x77, 0x61, 0x72, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x28, 0x01, 0x30, 0x01, 0x12, 0x56, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x17, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x14, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x30, 0x01, 0x42, 0x27, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f, 0x6c, 0x6e, 0x64, 0x2f, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( file_lightning_proto_rawDescOnce sync.Once file_lightning_proto_rawDescData = file_lightning_proto_rawDesc ) func file_lightning_proto_rawDescGZIP() []byte { file_lightning_proto_rawDescOnce.Do(func() { file_lightning_proto_rawDescData = protoimpl.X.CompressGZIP(file_lightning_proto_rawDescData) }) return file_lightning_proto_rawDescData } var file_lightning_proto_enumTypes = make([]protoimpl.EnumInfo, 19) var file_lightning_proto_msgTypes = make([]protoimpl.MessageInfo, 207) var file_lightning_proto_goTypes = []interface{}{ (AddressType)(0), // 0: lnrpc.AddressType (CommitmentType)(0), // 1: lnrpc.CommitmentType (Initiator)(0), // 2: lnrpc.Initiator (ResolutionType)(0), // 3: lnrpc.ResolutionType (ResolutionOutcome)(0), // 4: lnrpc.ResolutionOutcome (NodeMetricType)(0), // 5: lnrpc.NodeMetricType (InvoiceHTLCState)(0), // 6: lnrpc.InvoiceHTLCState (PaymentFailureReason)(0), // 7: lnrpc.PaymentFailureReason (FeatureBit)(0), // 8: lnrpc.FeatureBit (UpdateFailure)(0), // 9: lnrpc.UpdateFailure (ChannelCloseSummary_ClosureType)(0), // 10: lnrpc.ChannelCloseSummary.ClosureType (Peer_SyncType)(0), // 11: lnrpc.Peer.SyncType (PeerEvent_EventType)(0), // 12: lnrpc.PeerEvent.EventType (PendingChannelsResponse_ForceClosedChannel_AnchorState)(0), // 13: lnrpc.PendingChannelsResponse.ForceClosedChannel.AnchorState (ChannelEventUpdate_UpdateType)(0), // 14: lnrpc.ChannelEventUpdate.UpdateType (Invoice_InvoiceState)(0), // 15: lnrpc.Invoice.InvoiceState (Payment_PaymentStatus)(0), // 16: lnrpc.Payment.PaymentStatus (HTLCAttempt_HTLCStatus)(0), // 17: lnrpc.HTLCAttempt.HTLCStatus (Failure_FailureCode)(0), // 18: lnrpc.Failure.FailureCode (*SubscribeCustomMessagesRequest)(nil), // 19: lnrpc.SubscribeCustomMessagesRequest (*CustomMessage)(nil), // 20: lnrpc.CustomMessage (*SendCustomMessageRequest)(nil), // 21: lnrpc.SendCustomMessageRequest (*SendCustomMessageResponse)(nil), // 22: lnrpc.SendCustomMessageResponse (*Utxo)(nil), // 23: lnrpc.Utxo (*Transaction)(nil), // 24: lnrpc.Transaction (*GetTransactionsRequest)(nil), // 25: lnrpc.GetTransactionsRequest (*TransactionDetails)(nil), // 26: lnrpc.TransactionDetails (*FeeLimit)(nil), // 27: lnrpc.FeeLimit (*SendRequest)(nil), // 28: lnrpc.SendRequest (*SendResponse)(nil), // 29: lnrpc.SendResponse (*SendToRouteRequest)(nil), // 30: lnrpc.SendToRouteRequest (*ChannelAcceptRequest)(nil), // 31: lnrpc.ChannelAcceptRequest (*ChannelAcceptResponse)(nil), // 32: lnrpc.ChannelAcceptResponse (*ChannelPoint)(nil), // 33: lnrpc.ChannelPoint (*OutPoint)(nil), // 34: lnrpc.OutPoint (*LightningAddress)(nil), // 35: lnrpc.LightningAddress (*EstimateFeeRequest)(nil), // 36: lnrpc.EstimateFeeRequest (*EstimateFeeResponse)(nil), // 37: lnrpc.EstimateFeeResponse (*SendManyRequest)(nil), // 38: lnrpc.SendManyRequest (*SendManyResponse)(nil), // 39: lnrpc.SendManyResponse (*SendCoinsRequest)(nil), // 40: lnrpc.SendCoinsRequest (*SendCoinsResponse)(nil), // 41: lnrpc.SendCoinsResponse (*ListUnspentRequest)(nil), // 42: lnrpc.ListUnspentRequest (*ListUnspentResponse)(nil), // 43: lnrpc.ListUnspentResponse (*NewAddressRequest)(nil), // 44: lnrpc.NewAddressRequest (*NewAddressResponse)(nil), // 45: lnrpc.NewAddressResponse (*SignMessageRequest)(nil), // 46: lnrpc.SignMessageRequest (*SignMessageResponse)(nil), // 47: lnrpc.SignMessageResponse (*VerifyMessageRequest)(nil), // 48: lnrpc.VerifyMessageRequest (*VerifyMessageResponse)(nil), // 49: lnrpc.VerifyMessageResponse (*ConnectPeerRequest)(nil), // 50: lnrpc.ConnectPeerRequest (*ConnectPeerResponse)(nil), // 51: lnrpc.ConnectPeerResponse (*DisconnectPeerRequest)(nil), // 52: lnrpc.DisconnectPeerRequest (*DisconnectPeerResponse)(nil), // 53: lnrpc.DisconnectPeerResponse (*HTLC)(nil), // 54: lnrpc.HTLC (*ChannelConstraints)(nil), // 55: lnrpc.ChannelConstraints (*Channel)(nil), // 56: lnrpc.Channel (*ListChannelsRequest)(nil), // 57: lnrpc.ListChannelsRequest (*ListChannelsResponse)(nil), // 58: lnrpc.ListChannelsResponse (*ChannelCloseSummary)(nil), // 59: lnrpc.ChannelCloseSummary (*Resolution)(nil), // 60: lnrpc.Resolution (*ClosedChannelsRequest)(nil), // 61: lnrpc.ClosedChannelsRequest (*ClosedChannelsResponse)(nil), // 62: lnrpc.ClosedChannelsResponse (*Peer)(nil), // 63: lnrpc.Peer (*TimestampedError)(nil), // 64: lnrpc.TimestampedError (*ListPeersRequest)(nil), // 65: lnrpc.ListPeersRequest (*ListPeersResponse)(nil), // 66: lnrpc.ListPeersResponse (*PeerEventSubscription)(nil), // 67: lnrpc.PeerEventSubscription (*PeerEvent)(nil), // 68: lnrpc.PeerEvent (*GetInfoRequest)(nil), // 69: lnrpc.GetInfoRequest (*GetInfoResponse)(nil), // 70: lnrpc.GetInfoResponse (*GetRecoveryInfoRequest)(nil), // 71: lnrpc.GetRecoveryInfoRequest (*GetRecoveryInfoResponse)(nil), // 72: lnrpc.GetRecoveryInfoResponse (*Chain)(nil), // 73: lnrpc.Chain (*ConfirmationUpdate)(nil), // 74: lnrpc.ConfirmationUpdate (*ChannelOpenUpdate)(nil), // 75: lnrpc.ChannelOpenUpdate (*ChannelCloseUpdate)(nil), // 76: lnrpc.ChannelCloseUpdate (*CloseChannelRequest)(nil), // 77: lnrpc.CloseChannelRequest (*CloseStatusUpdate)(nil), // 78: lnrpc.CloseStatusUpdate (*PendingUpdate)(nil), // 79: lnrpc.PendingUpdate (*ReadyForPsbtFunding)(nil), // 80: lnrpc.ReadyForPsbtFunding (*BatchOpenChannelRequest)(nil), // 81: lnrpc.BatchOpenChannelRequest (*BatchOpenChannel)(nil), // 82: lnrpc.BatchOpenChannel (*BatchOpenChannelResponse)(nil), // 83: lnrpc.BatchOpenChannelResponse (*OpenChannelRequest)(nil), // 84: lnrpc.OpenChannelRequest (*OpenStatusUpdate)(nil), // 85: lnrpc.OpenStatusUpdate (*KeyLocator)(nil), // 86: lnrpc.KeyLocator (*KeyDescriptor)(nil), // 87: lnrpc.KeyDescriptor (*ChanPointShim)(nil), // 88: lnrpc.ChanPointShim (*PsbtShim)(nil), // 89: lnrpc.PsbtShim (*FundingShim)(nil), // 90: lnrpc.FundingShim (*FundingShimCancel)(nil), // 91: lnrpc.FundingShimCancel (*FundingPsbtVerify)(nil), // 92: lnrpc.FundingPsbtVerify (*FundingPsbtFinalize)(nil), // 93: lnrpc.FundingPsbtFinalize (*FundingTransitionMsg)(nil), // 94: lnrpc.FundingTransitionMsg (*FundingStateStepResp)(nil), // 95: lnrpc.FundingStateStepResp (*PendingHTLC)(nil), // 96: lnrpc.PendingHTLC (*PendingChannelsRequest)(nil), // 97: lnrpc.PendingChannelsRequest (*PendingChannelsResponse)(nil), // 98: lnrpc.PendingChannelsResponse (*ChannelEventSubscription)(nil), // 99: lnrpc.ChannelEventSubscription (*ChannelEventUpdate)(nil), // 100: lnrpc.ChannelEventUpdate (*WalletAccountBalance)(nil), // 101: lnrpc.WalletAccountBalance (*WalletBalanceRequest)(nil), // 102: lnrpc.WalletBalanceRequest (*WalletBalanceResponse)(nil), // 103: lnrpc.WalletBalanceResponse (*Amount)(nil), // 104: lnrpc.Amount (*ChannelBalanceRequest)(nil), // 105: lnrpc.ChannelBalanceRequest (*ChannelBalanceResponse)(nil), // 106: lnrpc.ChannelBalanceResponse (*QueryRoutesRequest)(nil), // 107: lnrpc.QueryRoutesRequest (*NodePair)(nil), // 108: lnrpc.NodePair (*EdgeLocator)(nil), // 109: lnrpc.EdgeLocator (*QueryRoutesResponse)(nil), // 110: lnrpc.QueryRoutesResponse (*Hop)(nil), // 111: lnrpc.Hop (*MPPRecord)(nil), // 112: lnrpc.MPPRecord (*AMPRecord)(nil), // 113: lnrpc.AMPRecord (*Route)(nil), // 114: lnrpc.Route (*NodeInfoRequest)(nil), // 115: lnrpc.NodeInfoRequest (*NodeInfo)(nil), // 116: lnrpc.NodeInfo (*LightningNode)(nil), // 117: lnrpc.LightningNode (*NodeAddress)(nil), // 118: lnrpc.NodeAddress (*RoutingPolicy)(nil), // 119: lnrpc.RoutingPolicy (*ChannelEdge)(nil), // 120: lnrpc.ChannelEdge (*ChannelGraphRequest)(nil), // 121: lnrpc.ChannelGraphRequest (*ChannelGraph)(nil), // 122: lnrpc.ChannelGraph (*NodeMetricsRequest)(nil), // 123: lnrpc.NodeMetricsRequest (*NodeMetricsResponse)(nil), // 124: lnrpc.NodeMetricsResponse (*FloatMetric)(nil), // 125: lnrpc.FloatMetric (*ChanInfoRequest)(nil), // 126: lnrpc.ChanInfoRequest (*NetworkInfoRequest)(nil), // 127: lnrpc.NetworkInfoRequest (*NetworkInfo)(nil), // 128: lnrpc.NetworkInfo (*StopRequest)(nil), // 129: lnrpc.StopRequest (*StopResponse)(nil), // 130: lnrpc.StopResponse (*GraphTopologySubscription)(nil), // 131: lnrpc.GraphTopologySubscription (*GraphTopologyUpdate)(nil), // 132: lnrpc.GraphTopologyUpdate (*NodeUpdate)(nil), // 133: lnrpc.NodeUpdate (*ChannelEdgeUpdate)(nil), // 134: lnrpc.ChannelEdgeUpdate (*ClosedChannelUpdate)(nil), // 135: lnrpc.ClosedChannelUpdate (*HopHint)(nil), // 136: lnrpc.HopHint (*SetID)(nil), // 137: lnrpc.SetID (*RouteHint)(nil), // 138: lnrpc.RouteHint (*AMPInvoiceState)(nil), // 139: lnrpc.AMPInvoiceState (*Invoice)(nil), // 140: lnrpc.Invoice (*InvoiceHTLC)(nil), // 141: lnrpc.InvoiceHTLC (*AMP)(nil), // 142: lnrpc.AMP (*AddInvoiceResponse)(nil), // 143: lnrpc.AddInvoiceResponse (*PaymentHash)(nil), // 144: lnrpc.PaymentHash (*ListInvoiceRequest)(nil), // 145: lnrpc.ListInvoiceRequest (*ListInvoiceResponse)(nil), // 146: lnrpc.ListInvoiceResponse (*InvoiceSubscription)(nil), // 147: lnrpc.InvoiceSubscription (*Payment)(nil), // 148: lnrpc.Payment (*HTLCAttempt)(nil), // 149: lnrpc.HTLCAttempt (*ListPaymentsRequest)(nil), // 150: lnrpc.ListPaymentsRequest (*ListPaymentsResponse)(nil), // 151: lnrpc.ListPaymentsResponse (*DeletePaymentRequest)(nil), // 152: lnrpc.DeletePaymentRequest (*DeleteAllPaymentsRequest)(nil), // 153: lnrpc.DeleteAllPaymentsRequest (*DeletePaymentResponse)(nil), // 154: lnrpc.DeletePaymentResponse (*DeleteAllPaymentsResponse)(nil), // 155: lnrpc.DeleteAllPaymentsResponse (*AbandonChannelRequest)(nil), // 156: lnrpc.AbandonChannelRequest (*AbandonChannelResponse)(nil), // 157: lnrpc.AbandonChannelResponse (*DebugLevelRequest)(nil), // 158: lnrpc.DebugLevelRequest (*DebugLevelResponse)(nil), // 159: lnrpc.DebugLevelResponse (*PayReqString)(nil), // 160: lnrpc.PayReqString (*PayReq)(nil), // 161: lnrpc.PayReq (*Feature)(nil), // 162: lnrpc.Feature (*FeeReportRequest)(nil), // 163: lnrpc.FeeReportRequest (*ChannelFeeReport)(nil), // 164: lnrpc.ChannelFeeReport (*FeeReportResponse)(nil), // 165: lnrpc.FeeReportResponse (*PolicyUpdateRequest)(nil), // 166: lnrpc.PolicyUpdateRequest (*FailedUpdate)(nil), // 167: lnrpc.FailedUpdate (*PolicyUpdateResponse)(nil), // 168: lnrpc.PolicyUpdateResponse (*ForwardingHistoryRequest)(nil), // 169: lnrpc.ForwardingHistoryRequest (*ForwardingEvent)(nil), // 170: lnrpc.ForwardingEvent (*ForwardingHistoryResponse)(nil), // 171: lnrpc.ForwardingHistoryResponse (*ExportChannelBackupRequest)(nil), // 172: lnrpc.ExportChannelBackupRequest (*ChannelBackup)(nil), // 173: lnrpc.ChannelBackup (*MultiChanBackup)(nil), // 174: lnrpc.MultiChanBackup (*ChanBackupExportRequest)(nil), // 175: lnrpc.ChanBackupExportRequest (*ChanBackupSnapshot)(nil), // 176: lnrpc.ChanBackupSnapshot (*ChannelBackups)(nil), // 177: lnrpc.ChannelBackups (*RestoreChanBackupRequest)(nil), // 178: lnrpc.RestoreChanBackupRequest (*RestoreBackupResponse)(nil), // 179: lnrpc.RestoreBackupResponse (*ChannelBackupSubscription)(nil), // 180: lnrpc.ChannelBackupSubscription (*VerifyChanBackupResponse)(nil), // 181: lnrpc.VerifyChanBackupResponse (*MacaroonPermission)(nil), // 182: lnrpc.MacaroonPermission (*BakeMacaroonRequest)(nil), // 183: lnrpc.BakeMacaroonRequest (*BakeMacaroonResponse)(nil), // 184: lnrpc.BakeMacaroonResponse (*ListMacaroonIDsRequest)(nil), // 185: lnrpc.ListMacaroonIDsRequest (*ListMacaroonIDsResponse)(nil), // 186: lnrpc.ListMacaroonIDsResponse (*DeleteMacaroonIDRequest)(nil), // 187: lnrpc.DeleteMacaroonIDRequest (*DeleteMacaroonIDResponse)(nil), // 188: lnrpc.DeleteMacaroonIDResponse (*MacaroonPermissionList)(nil), // 189: lnrpc.MacaroonPermissionList (*ListPermissionsRequest)(nil), // 190: lnrpc.ListPermissionsRequest (*ListPermissionsResponse)(nil), // 191: lnrpc.ListPermissionsResponse (*Failure)(nil), // 192: lnrpc.Failure (*ChannelUpdate)(nil), // 193: lnrpc.ChannelUpdate (*MacaroonId)(nil), // 194: lnrpc.MacaroonId (*Op)(nil), // 195: lnrpc.Op (*CheckMacPermRequest)(nil), // 196: lnrpc.CheckMacPermRequest (*CheckMacPermResponse)(nil), // 197: lnrpc.CheckMacPermResponse (*RPCMiddlewareRequest)(nil), // 198: lnrpc.RPCMiddlewareRequest (*StreamAuth)(nil), // 199: lnrpc.StreamAuth (*RPCMessage)(nil), // 200: lnrpc.RPCMessage (*RPCMiddlewareResponse)(nil), // 201: lnrpc.RPCMiddlewareResponse (*MiddlewareRegistration)(nil), // 202: lnrpc.MiddlewareRegistration (*InterceptFeedback)(nil), // 203: lnrpc.InterceptFeedback nil, // 204: lnrpc.SendRequest.DestCustomRecordsEntry nil, // 205: lnrpc.EstimateFeeRequest.AddrToAmountEntry nil, // 206: lnrpc.SendManyRequest.AddrToAmountEntry nil, // 207: lnrpc.Peer.FeaturesEntry nil, // 208: lnrpc.GetInfoResponse.FeaturesEntry (*PendingChannelsResponse_PendingChannel)(nil), // 209: lnrpc.PendingChannelsResponse.PendingChannel (*PendingChannelsResponse_PendingOpenChannel)(nil), // 210: lnrpc.PendingChannelsResponse.PendingOpenChannel (*PendingChannelsResponse_WaitingCloseChannel)(nil), // 211: lnrpc.PendingChannelsResponse.WaitingCloseChannel (*PendingChannelsResponse_Commitments)(nil), // 212: lnrpc.PendingChannelsResponse.Commitments (*PendingChannelsResponse_ClosedChannel)(nil), // 213: lnrpc.PendingChannelsResponse.ClosedChannel (*PendingChannelsResponse_ForceClosedChannel)(nil), // 214: lnrpc.PendingChannelsResponse.ForceClosedChannel nil, // 215: lnrpc.WalletBalanceResponse.AccountBalanceEntry nil, // 216: lnrpc.QueryRoutesRequest.DestCustomRecordsEntry nil, // 217: lnrpc.Hop.CustomRecordsEntry nil, // 218: lnrpc.LightningNode.FeaturesEntry nil, // 219: lnrpc.NodeMetricsResponse.BetweennessCentralityEntry nil, // 220: lnrpc.NodeUpdate.FeaturesEntry nil, // 221: lnrpc.Invoice.FeaturesEntry nil, // 222: lnrpc.Invoice.AmpInvoiceStateEntry nil, // 223: lnrpc.InvoiceHTLC.CustomRecordsEntry nil, // 224: lnrpc.PayReq.FeaturesEntry nil, // 225: lnrpc.ListPermissionsResponse.MethodPermissionsEntry } var file_lightning_proto_depIdxs = []int32{ 0, // 0: lnrpc.Utxo.address_type:type_name -> lnrpc.AddressType 34, // 1: lnrpc.Utxo.outpoint:type_name -> lnrpc.OutPoint 24, // 2: lnrpc.TransactionDetails.transactions:type_name -> lnrpc.Transaction 27, // 3: lnrpc.SendRequest.fee_limit:type_name -> lnrpc.FeeLimit 204, // 4: lnrpc.SendRequest.dest_custom_records:type_name -> lnrpc.SendRequest.DestCustomRecordsEntry 8, // 5: lnrpc.SendRequest.dest_features:type_name -> lnrpc.FeatureBit 114, // 6: lnrpc.SendResponse.payment_route:type_name -> lnrpc.Route 114, // 7: lnrpc.SendToRouteRequest.route:type_name -> lnrpc.Route 1, // 8: lnrpc.ChannelAcceptRequest.commitment_type:type_name -> lnrpc.CommitmentType 205, // 9: lnrpc.EstimateFeeRequest.AddrToAmount:type_name -> lnrpc.EstimateFeeRequest.AddrToAmountEntry 206, // 10: lnrpc.SendManyRequest.AddrToAmount:type_name -> lnrpc.SendManyRequest.AddrToAmountEntry 23, // 11: lnrpc.ListUnspentResponse.utxos:type_name -> lnrpc.Utxo 0, // 12: lnrpc.NewAddressRequest.type:type_name -> lnrpc.AddressType 35, // 13: lnrpc.ConnectPeerRequest.addr:type_name -> lnrpc.LightningAddress 54, // 14: lnrpc.Channel.pending_htlcs:type_name -> lnrpc.HTLC 1, // 15: lnrpc.Channel.commitment_type:type_name -> lnrpc.CommitmentType 55, // 16: lnrpc.Channel.local_constraints:type_name -> lnrpc.ChannelConstraints 55, // 17: lnrpc.Channel.remote_constraints:type_name -> lnrpc.ChannelConstraints 56, // 18: lnrpc.ListChannelsResponse.channels:type_name -> lnrpc.Channel 10, // 19: lnrpc.ChannelCloseSummary.close_type:type_name -> lnrpc.ChannelCloseSummary.ClosureType 2, // 20: lnrpc.ChannelCloseSummary.open_initiator:type_name -> lnrpc.Initiator 2, // 21: lnrpc.ChannelCloseSummary.close_initiator:type_name -> lnrpc.Initiator 60, // 22: lnrpc.ChannelCloseSummary.resolutions:type_name -> lnrpc.Resolution 3, // 23: lnrpc.Resolution.resolution_type:type_name -> lnrpc.ResolutionType 4, // 24: lnrpc.Resolution.outcome:type_name -> lnrpc.ResolutionOutcome 34, // 25: lnrpc.Resolution.outpoint:type_name -> lnrpc.OutPoint 59, // 26: lnrpc.ClosedChannelsResponse.channels:type_name -> lnrpc.ChannelCloseSummary 11, // 27: lnrpc.Peer.sync_type:type_name -> lnrpc.Peer.SyncType 207, // 28: lnrpc.Peer.features:type_name -> lnrpc.Peer.FeaturesEntry 64, // 29: lnrpc.Peer.errors:type_name -> lnrpc.TimestampedError 63, // 30: lnrpc.ListPeersResponse.peers:type_name -> lnrpc.Peer 12, // 31: lnrpc.PeerEvent.type:type_name -> lnrpc.PeerEvent.EventType 73, // 32: lnrpc.GetInfoResponse.chains:type_name -> lnrpc.Chain 208, // 33: lnrpc.GetInfoResponse.features:type_name -> lnrpc.GetInfoResponse.FeaturesEntry 33, // 34: lnrpc.ChannelOpenUpdate.channel_point:type_name -> lnrpc.ChannelPoint 33, // 35: lnrpc.CloseChannelRequest.channel_point:type_name -> lnrpc.ChannelPoint 79, // 36: lnrpc.CloseStatusUpdate.close_pending:type_name -> lnrpc.PendingUpdate 76, // 37: lnrpc.CloseStatusUpdate.chan_close:type_name -> lnrpc.ChannelCloseUpdate 82, // 38: lnrpc.BatchOpenChannelRequest.channels:type_name -> lnrpc.BatchOpenChannel 1, // 39: lnrpc.BatchOpenChannel.commitment_type:type_name -> lnrpc.CommitmentType 79, // 40: lnrpc.BatchOpenChannelResponse.pending_channels:type_name -> lnrpc.PendingUpdate 90, // 41: lnrpc.OpenChannelRequest.funding_shim:type_name -> lnrpc.FundingShim 1, // 42: lnrpc.OpenChannelRequest.commitment_type:type_name -> lnrpc.CommitmentType 79, // 43: lnrpc.OpenStatusUpdate.chan_pending:type_name -> lnrpc.PendingUpdate 75, // 44: lnrpc.OpenStatusUpdate.chan_open:type_name -> lnrpc.ChannelOpenUpdate 80, // 45: lnrpc.OpenStatusUpdate.psbt_fund:type_name -> lnrpc.ReadyForPsbtFunding 86, // 46: lnrpc.KeyDescriptor.key_loc:type_name -> lnrpc.KeyLocator 33, // 47: lnrpc.ChanPointShim.chan_point:type_name -> lnrpc.ChannelPoint 87, // 48: lnrpc.ChanPointShim.local_key:type_name -> lnrpc.KeyDescriptor 88, // 49: lnrpc.FundingShim.chan_point_shim:type_name -> lnrpc.ChanPointShim 89, // 50: lnrpc.FundingShim.psbt_shim:type_name -> lnrpc.PsbtShim 90, // 51: lnrpc.FundingTransitionMsg.shim_register:type_name -> lnrpc.FundingShim 91, // 52: lnrpc.FundingTransitionMsg.shim_cancel:type_name -> lnrpc.FundingShimCancel 92, // 53: lnrpc.FundingTransitionMsg.psbt_verify:type_name -> lnrpc.FundingPsbtVerify 93, // 54: lnrpc.FundingTransitionMsg.psbt_finalize:type_name -> lnrpc.FundingPsbtFinalize 210, // 55: lnrpc.PendingChannelsResponse.pending_open_channels:type_name -> lnrpc.PendingChannelsResponse.PendingOpenChannel 213, // 56: lnrpc.PendingChannelsResponse.pending_closing_channels:type_name -> lnrpc.PendingChannelsResponse.ClosedChannel 214, // 57: lnrpc.PendingChannelsResponse.pending_force_closing_channels:type_name -> lnrpc.PendingChannelsResponse.ForceClosedChannel 211, // 58: lnrpc.PendingChannelsResponse.waiting_close_channels:type_name -> lnrpc.PendingChannelsResponse.WaitingCloseChannel 56, // 59: lnrpc.ChannelEventUpdate.open_channel:type_name -> lnrpc.Channel 59, // 60: lnrpc.ChannelEventUpdate.closed_channel:type_name -> lnrpc.ChannelCloseSummary 33, // 61: lnrpc.ChannelEventUpdate.active_channel:type_name -> lnrpc.ChannelPoint 33, // 62: lnrpc.ChannelEventUpdate.inactive_channel:type_name -> lnrpc.ChannelPoint 79, // 63: lnrpc.ChannelEventUpdate.pending_open_channel:type_name -> lnrpc.PendingUpdate 33, // 64: lnrpc.ChannelEventUpdate.fully_resolved_channel:type_name -> lnrpc.ChannelPoint 14, // 65: lnrpc.ChannelEventUpdate.type:type_name -> lnrpc.ChannelEventUpdate.UpdateType 215, // 66: lnrpc.WalletBalanceResponse.account_balance:type_name -> lnrpc.WalletBalanceResponse.AccountBalanceEntry 104, // 67: lnrpc.ChannelBalanceResponse.local_balance:type_name -> lnrpc.Amount 104, // 68: lnrpc.ChannelBalanceResponse.remote_balance:type_name -> lnrpc.Amount 104, // 69: lnrpc.ChannelBalanceResponse.unsettled_local_balance:type_name -> lnrpc.Amount 104, // 70: lnrpc.ChannelBalanceResponse.unsettled_remote_balance:type_name -> lnrpc.Amount 104, // 71: lnrpc.ChannelBalanceResponse.pending_open_local_balance:type_name -> lnrpc.Amount 104, // 72: lnrpc.ChannelBalanceResponse.pending_open_remote_balance:type_name -> lnrpc.Amount 27, // 73: lnrpc.QueryRoutesRequest.fee_limit:type_name -> lnrpc.FeeLimit 109, // 74: lnrpc.QueryRoutesRequest.ignored_edges:type_name -> lnrpc.EdgeLocator 108, // 75: lnrpc.QueryRoutesRequest.ignored_pairs:type_name -> lnrpc.NodePair 216, // 76: lnrpc.QueryRoutesRequest.dest_custom_records:type_name -> lnrpc.QueryRoutesRequest.DestCustomRecordsEntry 138, // 77: lnrpc.QueryRoutesRequest.route_hints:type_name -> lnrpc.RouteHint 8, // 78: lnrpc.QueryRoutesRequest.dest_features:type_name -> lnrpc.FeatureBit 114, // 79: lnrpc.QueryRoutesResponse.routes:type_name -> lnrpc.Route 112, // 80: lnrpc.Hop.mpp_record:type_name -> lnrpc.MPPRecord 113, // 81: lnrpc.Hop.amp_record:type_name -> lnrpc.AMPRecord 217, // 82: lnrpc.Hop.custom_records:type_name -> lnrpc.Hop.CustomRecordsEntry 111, // 83: lnrpc.Route.hops:type_name -> lnrpc.Hop 117, // 84: lnrpc.NodeInfo.node:type_name -> lnrpc.LightningNode 120, // 85: lnrpc.NodeInfo.channels:type_name -> lnrpc.ChannelEdge 118, // 86: lnrpc.LightningNode.addresses:type_name -> lnrpc.NodeAddress 218, // 87: lnrpc.LightningNode.features:type_name -> lnrpc.LightningNode.FeaturesEntry 119, // 88: lnrpc.ChannelEdge.node1_policy:type_name -> lnrpc.RoutingPolicy 119, // 89: lnrpc.ChannelEdge.node2_policy:type_name -> lnrpc.RoutingPolicy 117, // 90: lnrpc.ChannelGraph.nodes:type_name -> lnrpc.LightningNode 120, // 91: lnrpc.ChannelGraph.edges:type_name -> lnrpc.ChannelEdge 5, // 92: lnrpc.NodeMetricsRequest.types:type_name -> lnrpc.NodeMetricType 219, // 93: lnrpc.NodeMetricsResponse.betweenness_centrality:type_name -> lnrpc.NodeMetricsResponse.BetweennessCentralityEntry 133, // 94: lnrpc.GraphTopologyUpdate.node_updates:type_name -> lnrpc.NodeUpdate 134, // 95: lnrpc.GraphTopologyUpdate.channel_updates:type_name -> lnrpc.ChannelEdgeUpdate 135, // 96: lnrpc.GraphTopologyUpdate.closed_chans:type_name -> lnrpc.ClosedChannelUpdate 118, // 97: lnrpc.NodeUpdate.node_addresses:type_name -> lnrpc.NodeAddress 220, // 98: lnrpc.NodeUpdate.features:type_name -> lnrpc.NodeUpdate.FeaturesEntry 33, // 99: lnrpc.ChannelEdgeUpdate.chan_point:type_name -> lnrpc.ChannelPoint 119, // 100: lnrpc.ChannelEdgeUpdate.routing_policy:type_name -> lnrpc.RoutingPolicy 33, // 101: lnrpc.ClosedChannelUpdate.chan_point:type_name -> lnrpc.ChannelPoint 136, // 102: lnrpc.RouteHint.hop_hints:type_name -> lnrpc.HopHint 6, // 103: lnrpc.AMPInvoiceState.state:type_name -> lnrpc.InvoiceHTLCState 138, // 104: lnrpc.Invoice.route_hints:type_name -> lnrpc.RouteHint 15, // 105: lnrpc.Invoice.state:type_name -> lnrpc.Invoice.InvoiceState 141, // 106: lnrpc.Invoice.htlcs:type_name -> lnrpc.InvoiceHTLC 221, // 107: lnrpc.Invoice.features:type_name -> lnrpc.Invoice.FeaturesEntry 222, // 108: lnrpc.Invoice.amp_invoice_state:type_name -> lnrpc.Invoice.AmpInvoiceStateEntry 6, // 109: lnrpc.InvoiceHTLC.state:type_name -> lnrpc.InvoiceHTLCState 223, // 110: lnrpc.InvoiceHTLC.custom_records:type_name -> lnrpc.InvoiceHTLC.CustomRecordsEntry 142, // 111: lnrpc.InvoiceHTLC.amp:type_name -> lnrpc.AMP 140, // 112: lnrpc.ListInvoiceResponse.invoices:type_name -> lnrpc.Invoice 16, // 113: lnrpc.Payment.status:type_name -> lnrpc.Payment.PaymentStatus 149, // 114: lnrpc.Payment.htlcs:type_name -> lnrpc.HTLCAttempt 7, // 115: lnrpc.Payment.failure_reason:type_name -> lnrpc.PaymentFailureReason 17, // 116: lnrpc.HTLCAttempt.status:type_name -> lnrpc.HTLCAttempt.HTLCStatus 114, // 117: lnrpc.HTLCAttempt.route:type_name -> lnrpc.Route 192, // 118: lnrpc.HTLCAttempt.failure:type_name -> lnrpc.Failure 148, // 119: lnrpc.ListPaymentsResponse.payments:type_name -> lnrpc.Payment 33, // 120: lnrpc.AbandonChannelRequest.channel_point:type_name -> lnrpc.ChannelPoint 138, // 121: lnrpc.PayReq.route_hints:type_name -> lnrpc.RouteHint 224, // 122: lnrpc.PayReq.features:type_name -> lnrpc.PayReq.FeaturesEntry 164, // 123: lnrpc.FeeReportResponse.channel_fees:type_name -> lnrpc.ChannelFeeReport 33, // 124: lnrpc.PolicyUpdateRequest.chan_point:type_name -> lnrpc.ChannelPoint 34, // 125: lnrpc.FailedUpdate.outpoint:type_name -> lnrpc.OutPoint 9, // 126: lnrpc.FailedUpdate.reason:type_name -> lnrpc.UpdateFailure 167, // 127: lnrpc.PolicyUpdateResponse.failed_updates:type_name -> lnrpc.FailedUpdate 170, // 128: lnrpc.ForwardingHistoryResponse.forwarding_events:type_name -> lnrpc.ForwardingEvent 33, // 129: lnrpc.ExportChannelBackupRequest.chan_point:type_name -> lnrpc.ChannelPoint 33, // 130: lnrpc.ChannelBackup.chan_point:type_name -> lnrpc.ChannelPoint 33, // 131: lnrpc.MultiChanBackup.chan_points:type_name -> lnrpc.ChannelPoint 177, // 132: lnrpc.ChanBackupSnapshot.single_chan_backups:type_name -> lnrpc.ChannelBackups 174, // 133: lnrpc.ChanBackupSnapshot.multi_chan_backup:type_name -> lnrpc.MultiChanBackup 173, // 134: lnrpc.ChannelBackups.chan_backups:type_name -> lnrpc.ChannelBackup 177, // 135: lnrpc.RestoreChanBackupRequest.chan_backups:type_name -> lnrpc.ChannelBackups 182, // 136: lnrpc.BakeMacaroonRequest.permissions:type_name -> lnrpc.MacaroonPermission 182, // 137: lnrpc.MacaroonPermissionList.permissions:type_name -> lnrpc.MacaroonPermission 225, // 138: lnrpc.ListPermissionsResponse.method_permissions:type_name -> lnrpc.ListPermissionsResponse.MethodPermissionsEntry 18, // 139: lnrpc.Failure.code:type_name -> lnrpc.Failure.FailureCode 193, // 140: lnrpc.Failure.channel_update:type_name -> lnrpc.ChannelUpdate 195, // 141: lnrpc.MacaroonId.ops:type_name -> lnrpc.Op 182, // 142: lnrpc.CheckMacPermRequest.permissions:type_name -> lnrpc.MacaroonPermission 199, // 143: lnrpc.RPCMiddlewareRequest.stream_auth:type_name -> lnrpc.StreamAuth 200, // 144: lnrpc.RPCMiddlewareRequest.request:type_name -> lnrpc.RPCMessage 200, // 145: lnrpc.RPCMiddlewareRequest.response:type_name -> lnrpc.RPCMessage 202, // 146: lnrpc.RPCMiddlewareResponse.register:type_name -> lnrpc.MiddlewareRegistration 203, // 147: lnrpc.RPCMiddlewareResponse.feedback:type_name -> lnrpc.InterceptFeedback 162, // 148: lnrpc.Peer.FeaturesEntry.value:type_name -> lnrpc.Feature 162, // 149: lnrpc.GetInfoResponse.FeaturesEntry.value:type_name -> lnrpc.Feature 2, // 150: lnrpc.PendingChannelsResponse.PendingChannel.initiator:type_name -> lnrpc.Initiator 1, // 151: lnrpc.PendingChannelsResponse.PendingChannel.commitment_type:type_name -> lnrpc.CommitmentType 209, // 152: lnrpc.PendingChannelsResponse.PendingOpenChannel.channel:type_name -> lnrpc.PendingChannelsResponse.PendingChannel 209, // 153: lnrpc.PendingChannelsResponse.WaitingCloseChannel.channel:type_name -> lnrpc.PendingChannelsResponse.PendingChannel 212, // 154: lnrpc.PendingChannelsResponse.WaitingCloseChannel.commitments:type_name -> lnrpc.PendingChannelsResponse.Commitments 209, // 155: lnrpc.PendingChannelsResponse.ClosedChannel.channel:type_name -> lnrpc.PendingChannelsResponse.PendingChannel 209, // 156: lnrpc.PendingChannelsResponse.ForceClosedChannel.channel:type_name -> lnrpc.PendingChannelsResponse.PendingChannel 96, // 157: lnrpc.PendingChannelsResponse.ForceClosedChannel.pending_htlcs:type_name -> lnrpc.PendingHTLC 13, // 158: lnrpc.PendingChannelsResponse.ForceClosedChannel.anchor:type_name -> lnrpc.PendingChannelsResponse.ForceClosedChannel.AnchorState 101, // 159: lnrpc.WalletBalanceResponse.AccountBalanceEntry.value:type_name -> lnrpc.WalletAccountBalance 162, // 160: lnrpc.LightningNode.FeaturesEntry.value:type_name -> lnrpc.Feature 125, // 161: lnrpc.NodeMetricsResponse.BetweennessCentralityEntry.value:type_name -> lnrpc.FloatMetric 162, // 162: lnrpc.NodeUpdate.FeaturesEntry.value:type_name -> lnrpc.Feature 162, // 163: lnrpc.Invoice.FeaturesEntry.value:type_name -> lnrpc.Feature 139, // 164: lnrpc.Invoice.AmpInvoiceStateEntry.value:type_name -> lnrpc.AMPInvoiceState 162, // 165: lnrpc.PayReq.FeaturesEntry.value:type_name -> lnrpc.Feature 189, // 166: lnrpc.ListPermissionsResponse.MethodPermissionsEntry.value:type_name -> lnrpc.MacaroonPermissionList 102, // 167: lnrpc.Lightning.WalletBalance:input_type -> lnrpc.WalletBalanceRequest 105, // 168: lnrpc.Lightning.ChannelBalance:input_type -> lnrpc.ChannelBalanceRequest 25, // 169: lnrpc.Lightning.GetTransactions:input_type -> lnrpc.GetTransactionsRequest 36, // 170: lnrpc.Lightning.EstimateFee:input_type -> lnrpc.EstimateFeeRequest 40, // 171: lnrpc.Lightning.SendCoins:input_type -> lnrpc.SendCoinsRequest 42, // 172: lnrpc.Lightning.ListUnspent:input_type -> lnrpc.ListUnspentRequest 25, // 173: lnrpc.Lightning.SubscribeTransactions:input_type -> lnrpc.GetTransactionsRequest 38, // 174: lnrpc.Lightning.SendMany:input_type -> lnrpc.SendManyRequest 44, // 175: lnrpc.Lightning.NewAddress:input_type -> lnrpc.NewAddressRequest 46, // 176: lnrpc.Lightning.SignMessage:input_type -> lnrpc.SignMessageRequest 48, // 177: lnrpc.Lightning.VerifyMessage:input_type -> lnrpc.VerifyMessageRequest 50, // 178: lnrpc.Lightning.ConnectPeer:input_type -> lnrpc.ConnectPeerRequest 52, // 179: lnrpc.Lightning.DisconnectPeer:input_type -> lnrpc.DisconnectPeerRequest 65, // 180: lnrpc.Lightning.ListPeers:input_type -> lnrpc.ListPeersRequest 67, // 181: lnrpc.Lightning.SubscribePeerEvents:input_type -> lnrpc.PeerEventSubscription 69, // 182: lnrpc.Lightning.GetInfo:input_type -> lnrpc.GetInfoRequest 71, // 183: lnrpc.Lightning.GetRecoveryInfo:input_type -> lnrpc.GetRecoveryInfoRequest 97, // 184: lnrpc.Lightning.PendingChannels:input_type -> lnrpc.PendingChannelsRequest 57, // 185: lnrpc.Lightning.ListChannels:input_type -> lnrpc.ListChannelsRequest 99, // 186: lnrpc.Lightning.SubscribeChannelEvents:input_type -> lnrpc.ChannelEventSubscription 61, // 187: lnrpc.Lightning.ClosedChannels:input_type -> lnrpc.ClosedChannelsRequest 84, // 188: lnrpc.Lightning.OpenChannelSync:input_type -> lnrpc.OpenChannelRequest 84, // 189: lnrpc.Lightning.OpenChannel:input_type -> lnrpc.OpenChannelRequest 81, // 190: lnrpc.Lightning.BatchOpenChannel:input_type -> lnrpc.BatchOpenChannelRequest 94, // 191: lnrpc.Lightning.FundingStateStep:input_type -> lnrpc.FundingTransitionMsg 32, // 192: lnrpc.Lightning.ChannelAcceptor:input_type -> lnrpc.ChannelAcceptResponse 77, // 193: lnrpc.Lightning.CloseChannel:input_type -> lnrpc.CloseChannelRequest 156, // 194: lnrpc.Lightning.AbandonChannel:input_type -> lnrpc.AbandonChannelRequest 28, // 195: lnrpc.Lightning.SendPayment:input_type -> lnrpc.SendRequest 28, // 196: lnrpc.Lightning.SendPaymentSync:input_type -> lnrpc.SendRequest 30, // 197: lnrpc.Lightning.SendToRoute:input_type -> lnrpc.SendToRouteRequest 30, // 198: lnrpc.Lightning.SendToRouteSync:input_type -> lnrpc.SendToRouteRequest 140, // 199: lnrpc.Lightning.AddInvoice:input_type -> lnrpc.Invoice 145, // 200: lnrpc.Lightning.ListInvoices:input_type -> lnrpc.ListInvoiceRequest 144, // 201: lnrpc.Lightning.LookupInvoice:input_type -> lnrpc.PaymentHash 147, // 202: lnrpc.Lightning.SubscribeInvoices:input_type -> lnrpc.InvoiceSubscription 160, // 203: lnrpc.Lightning.DecodePayReq:input_type -> lnrpc.PayReqString 150, // 204: lnrpc.Lightning.ListPayments:input_type -> lnrpc.ListPaymentsRequest 152, // 205: lnrpc.Lightning.DeletePayment:input_type -> lnrpc.DeletePaymentRequest 153, // 206: lnrpc.Lightning.DeleteAllPayments:input_type -> lnrpc.DeleteAllPaymentsRequest 121, // 207: lnrpc.Lightning.DescribeGraph:input_type -> lnrpc.ChannelGraphRequest 123, // 208: lnrpc.Lightning.GetNodeMetrics:input_type -> lnrpc.NodeMetricsRequest 126, // 209: lnrpc.Lightning.GetChanInfo:input_type -> lnrpc.ChanInfoRequest 115, // 210: lnrpc.Lightning.GetNodeInfo:input_type -> lnrpc.NodeInfoRequest 107, // 211: lnrpc.Lightning.QueryRoutes:input_type -> lnrpc.QueryRoutesRequest 127, // 212: lnrpc.Lightning.GetNetworkInfo:input_type -> lnrpc.NetworkInfoRequest 129, // 213: lnrpc.Lightning.StopDaemon:input_type -> lnrpc.StopRequest 131, // 214: lnrpc.Lightning.SubscribeChannelGraph:input_type -> lnrpc.GraphTopologySubscription 158, // 215: lnrpc.Lightning.DebugLevel:input_type -> lnrpc.DebugLevelRequest 163, // 216: lnrpc.Lightning.FeeReport:input_type -> lnrpc.FeeReportRequest 166, // 217: lnrpc.Lightning.UpdateChannelPolicy:input_type -> lnrpc.PolicyUpdateRequest 169, // 218: lnrpc.Lightning.ForwardingHistory:input_type -> lnrpc.ForwardingHistoryRequest 172, // 219: lnrpc.Lightning.ExportChannelBackup:input_type -> lnrpc.ExportChannelBackupRequest 175, // 220: lnrpc.Lightning.ExportAllChannelBackups:input_type -> lnrpc.ChanBackupExportRequest 176, // 221: lnrpc.Lightning.VerifyChanBackup:input_type -> lnrpc.ChanBackupSnapshot 178, // 222: lnrpc.Lightning.RestoreChannelBackups:input_type -> lnrpc.RestoreChanBackupRequest 180, // 223: lnrpc.Lightning.SubscribeChannelBackups:input_type -> lnrpc.ChannelBackupSubscription 183, // 224: lnrpc.Lightning.BakeMacaroon:input_type -> lnrpc.BakeMacaroonRequest 185, // 225: lnrpc.Lightning.ListMacaroonIDs:input_type -> lnrpc.ListMacaroonIDsRequest 187, // 226: lnrpc.Lightning.DeleteMacaroonID:input_type -> lnrpc.DeleteMacaroonIDRequest 190, // 227: lnrpc.Lightning.ListPermissions:input_type -> lnrpc.ListPermissionsRequest 196, // 228: lnrpc.Lightning.CheckMacaroonPermissions:input_type -> lnrpc.CheckMacPermRequest 201, // 229: lnrpc.Lightning.RegisterRPCMiddleware:input_type -> lnrpc.RPCMiddlewareResponse 21, // 230: lnrpc.Lightning.SendCustomMessage:input_type -> lnrpc.SendCustomMessageRequest 19, // 231: lnrpc.Lightning.SubscribeCustomMessages:input_type -> lnrpc.SubscribeCustomMessagesRequest 103, // 232: lnrpc.Lightning.WalletBalance:output_type -> lnrpc.WalletBalanceResponse 106, // 233: lnrpc.Lightning.ChannelBalance:output_type -> lnrpc.ChannelBalanceResponse 26, // 234: lnrpc.Lightning.GetTransactions:output_type -> lnrpc.TransactionDetails 37, // 235: lnrpc.Lightning.EstimateFee:output_type -> lnrpc.EstimateFeeResponse 41, // 236: lnrpc.Lightning.SendCoins:output_type -> lnrpc.SendCoinsResponse 43, // 237: lnrpc.Lightning.ListUnspent:output_type -> lnrpc.ListUnspentResponse 24, // 238: lnrpc.Lightning.SubscribeTransactions:output_type -> lnrpc.Transaction 39, // 239: lnrpc.Lightning.SendMany:output_type -> lnrpc.SendManyResponse 45, // 240: lnrpc.Lightning.NewAddress:output_type -> lnrpc.NewAddressResponse 47, // 241: lnrpc.Lightning.SignMessage:output_type -> lnrpc.SignMessageResponse 49, // 242: lnrpc.Lightning.VerifyMessage:output_type -> lnrpc.VerifyMessageResponse 51, // 243: lnrpc.Lightning.ConnectPeer:output_type -> lnrpc.ConnectPeerResponse 53, // 244: lnrpc.Lightning.DisconnectPeer:output_type -> lnrpc.DisconnectPeerResponse 66, // 245: lnrpc.Lightning.ListPeers:output_type -> lnrpc.ListPeersResponse 68, // 246: lnrpc.Lightning.SubscribePeerEvents:output_type -> lnrpc.PeerEvent 70, // 247: lnrpc.Lightning.GetInfo:output_type -> lnrpc.GetInfoResponse 72, // 248: lnrpc.Lightning.GetRecoveryInfo:output_type -> lnrpc.GetRecoveryInfoResponse 98, // 249: lnrpc.Lightning.PendingChannels:output_type -> lnrpc.PendingChannelsResponse 58, // 250: lnrpc.Lightning.ListChannels:output_type -> lnrpc.ListChannelsResponse 100, // 251: lnrpc.Lightning.SubscribeChannelEvents:output_type -> lnrpc.ChannelEventUpdate 62, // 252: lnrpc.Lightning.ClosedChannels:output_type -> lnrpc.ClosedChannelsResponse 33, // 253: lnrpc.Lightning.OpenChannelSync:output_type -> lnrpc.ChannelPoint 85, // 254: lnrpc.Lightning.OpenChannel:output_type -> lnrpc.OpenStatusUpdate 83, // 255: lnrpc.Lightning.BatchOpenChannel:output_type -> lnrpc.BatchOpenChannelResponse 95, // 256: lnrpc.Lightning.FundingStateStep:output_type -> lnrpc.FundingStateStepResp 31, // 257: lnrpc.Lightning.ChannelAcceptor:output_type -> lnrpc.ChannelAcceptRequest 78, // 258: lnrpc.Lightning.CloseChannel:output_type -> lnrpc.CloseStatusUpdate 157, // 259: lnrpc.Lightning.AbandonChannel:output_type -> lnrpc.AbandonChannelResponse 29, // 260: lnrpc.Lightning.SendPayment:output_type -> lnrpc.SendResponse 29, // 261: lnrpc.Lightning.SendPaymentSync:output_type -> lnrpc.SendResponse 29, // 262: lnrpc.Lightning.SendToRoute:output_type -> lnrpc.SendResponse 29, // 263: lnrpc.Lightning.SendToRouteSync:output_type -> lnrpc.SendResponse 143, // 264: lnrpc.Lightning.AddInvoice:output_type -> lnrpc.AddInvoiceResponse 146, // 265: lnrpc.Lightning.ListInvoices:output_type -> lnrpc.ListInvoiceResponse 140, // 266: lnrpc.Lightning.LookupInvoice:output_type -> lnrpc.Invoice 140, // 267: lnrpc.Lightning.SubscribeInvoices:output_type -> lnrpc.Invoice 161, // 268: lnrpc.Lightning.DecodePayReq:output_type -> lnrpc.PayReq 151, // 269: lnrpc.Lightning.ListPayments:output_type -> lnrpc.ListPaymentsResponse 154, // 270: lnrpc.Lightning.DeletePayment:output_type -> lnrpc.DeletePaymentResponse 155, // 271: lnrpc.Lightning.DeleteAllPayments:output_type -> lnrpc.DeleteAllPaymentsResponse 122, // 272: lnrpc.Lightning.DescribeGraph:output_type -> lnrpc.ChannelGraph 124, // 273: lnrpc.Lightning.GetNodeMetrics:output_type -> lnrpc.NodeMetricsResponse 120, // 274: lnrpc.Lightning.GetChanInfo:output_type -> lnrpc.ChannelEdge 116, // 275: lnrpc.Lightning.GetNodeInfo:output_type -> lnrpc.NodeInfo 110, // 276: lnrpc.Lightning.QueryRoutes:output_type -> lnrpc.QueryRoutesResponse 128, // 277: lnrpc.Lightning.GetNetworkInfo:output_type -> lnrpc.NetworkInfo 130, // 278: lnrpc.Lightning.StopDaemon:output_type -> lnrpc.StopResponse 132, // 279: lnrpc.Lightning.SubscribeChannelGraph:output_type -> lnrpc.GraphTopologyUpdate 159, // 280: lnrpc.Lightning.DebugLevel:output_type -> lnrpc.DebugLevelResponse 165, // 281: lnrpc.Lightning.FeeReport:output_type -> lnrpc.FeeReportResponse 168, // 282: lnrpc.Lightning.UpdateChannelPolicy:output_type -> lnrpc.PolicyUpdateResponse 171, // 283: lnrpc.Lightning.ForwardingHistory:output_type -> lnrpc.ForwardingHistoryResponse 173, // 284: lnrpc.Lightning.ExportChannelBackup:output_type -> lnrpc.ChannelBackup 176, // 285: lnrpc.Lightning.ExportAllChannelBackups:output_type -> lnrpc.ChanBackupSnapshot 181, // 286: lnrpc.Lightning.VerifyChanBackup:output_type -> lnrpc.VerifyChanBackupResponse 179, // 287: lnrpc.Lightning.RestoreChannelBackups:output_type -> lnrpc.RestoreBackupResponse 176, // 288: lnrpc.Lightning.SubscribeChannelBackups:output_type -> lnrpc.ChanBackupSnapshot 184, // 289: lnrpc.Lightning.BakeMacaroon:output_type -> lnrpc.BakeMacaroonResponse 186, // 290: lnrpc.Lightning.ListMacaroonIDs:output_type -> lnrpc.ListMacaroonIDsResponse 188, // 291: lnrpc.Lightning.DeleteMacaroonID:output_type -> lnrpc.DeleteMacaroonIDResponse 191, // 292: lnrpc.Lightning.ListPermissions:output_type -> lnrpc.ListPermissionsResponse 197, // 293: lnrpc.Lightning.CheckMacaroonPermissions:output_type -> lnrpc.CheckMacPermResponse 198, // 294: lnrpc.Lightning.RegisterRPCMiddleware:output_type -> lnrpc.RPCMiddlewareRequest 22, // 295: lnrpc.Lightning.SendCustomMessage:output_type -> lnrpc.SendCustomMessageResponse 20, // 296: lnrpc.Lightning.SubscribeCustomMessages:output_type -> lnrpc.CustomMessage 232, // [232:297] is the sub-list for method output_type 167, // [167:232] is the sub-list for method input_type 167, // [167:167] is the sub-list for extension type_name 167, // [167:167] is the sub-list for extension extendee 0, // [0:167] is the sub-list for field type_name } func init() { file_lightning_proto_init() } func file_lightning_proto_init() { if File_lightning_proto != nil { return } if !protoimpl.UnsafeEnabled { file_lightning_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SubscribeCustomMessagesRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CustomMessage); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendCustomMessageRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendCustomMessageResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Utxo); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Transaction); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetTransactionsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TransactionDetails); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FeeLimit); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendToRouteRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelAcceptRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelAcceptResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelPoint); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*OutPoint); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LightningAddress); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*EstimateFeeRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*EstimateFeeResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendManyRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendManyResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendCoinsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SendCoinsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListUnspentRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListUnspentResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NewAddressRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NewAddressResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SignMessageRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SignMessageResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VerifyMessageRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VerifyMessageResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ConnectPeerRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ConnectPeerResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DisconnectPeerRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DisconnectPeerResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HTLC); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelConstraints); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Channel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListChannelsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListChannelsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelCloseSummary); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Resolution); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ClosedChannelsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ClosedChannelsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Peer); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*TimestampedError); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPeersRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPeersResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PeerEventSubscription); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PeerEvent); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetInfoRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetInfoResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetRecoveryInfoRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GetRecoveryInfoResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Chain); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ConfirmationUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelOpenUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelCloseUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CloseChannelRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CloseStatusUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ReadyForPsbtFunding); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BatchOpenChannelRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BatchOpenChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BatchOpenChannelResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*OpenChannelRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*OpenStatusUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KeyLocator); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KeyDescriptor); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChanPointShim); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PsbtShim); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingShim); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingShimCancel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingPsbtVerify); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingPsbtFinalize); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingTransitionMsg); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FundingStateStepResp); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingHTLC); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelEventSubscription); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelEventUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WalletAccountBalance); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WalletBalanceRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*WalletBalanceResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Amount); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelBalanceRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelBalanceResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*QueryRoutesRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodePair); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*EdgeLocator); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*QueryRoutesResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Hop); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MPPRecord); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AMPRecord); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Route); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeInfoRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeInfo); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*LightningNode); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeAddress); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RoutingPolicy); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelEdge); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelGraphRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelGraph); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeMetricsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeMetricsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FloatMetric); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChanInfoRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NetworkInfoRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NetworkInfo); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StopRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StopResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[112].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GraphTopologySubscription); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[113].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*GraphTopologyUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[114].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*NodeUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[115].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelEdgeUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[116].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ClosedChannelUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[117].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HopHint); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[118].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*SetID); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[119].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RouteHint); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[120].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AMPInvoiceState); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[121].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Invoice); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[122].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InvoiceHTLC); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[123].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AMP); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[124].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AddInvoiceResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[125].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PaymentHash); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[126].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListInvoiceRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[127].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListInvoiceResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[128].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InvoiceSubscription); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[129].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Payment); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[130].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*HTLCAttempt); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[131].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPaymentsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[132].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPaymentsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[133].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeletePaymentRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[134].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeleteAllPaymentsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[135].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeletePaymentResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[136].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeleteAllPaymentsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[137].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AbandonChannelRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[138].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*AbandonChannelResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[139].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DebugLevelRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[140].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DebugLevelResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[141].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PayReqString); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[142].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PayReq); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[143].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Feature); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[144].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FeeReportRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[145].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelFeeReport); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[146].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FeeReportResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[147].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PolicyUpdateRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[148].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*FailedUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[149].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PolicyUpdateResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[150].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ForwardingHistoryRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[151].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ForwardingEvent); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[152].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ForwardingHistoryResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[153].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ExportChannelBackupRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[154].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelBackup); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[155].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MultiChanBackup); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[156].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChanBackupExportRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[157].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChanBackupSnapshot); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[158].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelBackups); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[159].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RestoreChanBackupRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[160].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RestoreBackupResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[161].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelBackupSubscription); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[162].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*VerifyChanBackupResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[163].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MacaroonPermission); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[164].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BakeMacaroonRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[165].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*BakeMacaroonResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[166].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListMacaroonIDsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[167].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListMacaroonIDsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[168].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeleteMacaroonIDRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[169].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*DeleteMacaroonIDResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[170].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MacaroonPermissionList); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[171].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPermissionsRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[172].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListPermissionsResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[173].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Failure); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[174].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ChannelUpdate); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[175].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MacaroonId); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[176].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*Op); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[177].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CheckMacPermRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[178].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CheckMacPermResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[179].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RPCMiddlewareRequest); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[180].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*StreamAuth); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[181].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RPCMessage); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[182].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RPCMiddlewareResponse); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[183].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*MiddlewareRegistration); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[184].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*InterceptFeedback); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[190].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_PendingChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[191].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_PendingOpenChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[192].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_WaitingCloseChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[193].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_Commitments); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[194].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_ClosedChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } file_lightning_proto_msgTypes[195].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PendingChannelsResponse_ForceClosedChannel); i { case 0: return &v.state case 1: return &v.sizeCache case 2: return &v.unknownFields default: return nil } } } file_lightning_proto_msgTypes[8].OneofWrappers = []interface{}{ (*FeeLimit_Fixed)(nil), (*FeeLimit_FixedMsat)(nil), (*FeeLimit_Percent)(nil), } file_lightning_proto_msgTypes[14].OneofWrappers = []interface{}{ (*ChannelPoint_FundingTxidBytes)(nil), (*ChannelPoint_FundingTxidStr)(nil), } file_lightning_proto_msgTypes[59].OneofWrappers = []interface{}{ (*CloseStatusUpdate_ClosePending)(nil), (*CloseStatusUpdate_ChanClose)(nil), } file_lightning_proto_msgTypes[66].OneofWrappers = []interface{}{ (*OpenStatusUpdate_ChanPending)(nil), (*OpenStatusUpdate_ChanOpen)(nil), (*OpenStatusUpdate_PsbtFund)(nil), } file_lightning_proto_msgTypes[71].OneofWrappers = []interface{}{ (*FundingShim_ChanPointShim)(nil), (*FundingShim_PsbtShim)(nil), } file_lightning_proto_msgTypes[75].OneofWrappers = []interface{}{ (*FundingTransitionMsg_ShimRegister)(nil), (*FundingTransitionMsg_ShimCancel)(nil), (*FundingTransitionMsg_PsbtVerify)(nil), (*FundingTransitionMsg_PsbtFinalize)(nil), } file_lightning_proto_msgTypes[81].OneofWrappers = []interface{}{ (*ChannelEventUpdate_OpenChannel)(nil), (*ChannelEventUpdate_ClosedChannel)(nil), (*ChannelEventUpdate_ActiveChannel)(nil), (*ChannelEventUpdate_InactiveChannel)(nil), (*ChannelEventUpdate_PendingOpenChannel)(nil), (*ChannelEventUpdate_FullyResolvedChannel)(nil), } file_lightning_proto_msgTypes[147].OneofWrappers = []interface{}{ (*PolicyUpdateRequest_Global)(nil), (*PolicyUpdateRequest_ChanPoint)(nil), } file_lightning_proto_msgTypes[159].OneofWrappers = []interface{}{ (*RestoreChanBackupRequest_ChanBackups)(nil), (*RestoreChanBackupRequest_MultiChanBackup)(nil), } file_lightning_proto_msgTypes[179].OneofWrappers = []interface{}{ (*RPCMiddlewareRequest_StreamAuth)(nil), (*RPCMiddlewareRequest_Request)(nil), (*RPCMiddlewareRequest_Response)(nil), } file_lightning_proto_msgTypes[182].OneofWrappers = []interface{}{ (*RPCMiddlewareResponse_Register)(nil), (*RPCMiddlewareResponse_Feedback)(nil), } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_lightning_proto_rawDesc, NumEnums: 19, NumMessages: 207, NumExtensions: 0, NumServices: 1, }, GoTypes: file_lightning_proto_goTypes, DependencyIndexes: file_lightning_proto_depIdxs, EnumInfos: file_lightning_proto_enumTypes, MessageInfos: file_lightning_proto_msgTypes, }.Build() File_lightning_proto = out.File file_lightning_proto_rawDesc = nil file_lightning_proto_goTypes = nil file_lightning_proto_depIdxs = nil }
{ ms.StoreMessageInfo(mi) }
indexedsharedflowableimpl.py
from dataclasses import replace from dataclass_abc import dataclass_abc from rxbp.indexed.indexedflowable import IndexedFlowable from rxbp.indexed.indexedsharedflowable import IndexedSharedFlowable from rxbp.indexed.mixins.indexedflowablemixin import IndexedFlowableMixin from rxbp.typing import ValueType @dataclass_abc class IndexedSharedFlowableImpl(IndexedSharedFlowable[ValueType]): underlying: IndexedFlowableMixin def
( self, is_shared: bool = None, **kwargs, ): return replace(self, **kwargs)
_copy
interpod_affinity.go
/* Copyright 2016 The Kubernetes Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package priorities import ( "context" "sync/atomic" "k8s.io/api/core/v1" apierrors "k8s.io/apimachinery/pkg/api/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/util/workqueue" "k8s.io/kubernetes/pkg/scheduler/algorithm/predicates" priorityutil "k8s.io/kubernetes/pkg/scheduler/algorithm/priorities/util" schedulerapi "k8s.io/kubernetes/pkg/scheduler/api" schedulernodeinfo "k8s.io/kubernetes/pkg/scheduler/nodeinfo" schedutil "k8s.io/kubernetes/pkg/scheduler/util" "k8s.io/klog" ) // InterPodAffinity contains information to calculate inter pod affinity. type InterPodAffinity struct { info predicates.NodeInfo hardPodAffinityWeight int32 } // NewInterPodAffinityPriority creates an InterPodAffinity. func NewInterPodAffinityPriority( info predicates.NodeInfo, hardPodAffinityWeight int32) PriorityFunction { interPodAffinity := &InterPodAffinity{ info: info, hardPodAffinityWeight: hardPodAffinityWeight, } return interPodAffinity.CalculateInterPodAffinityPriority } type podAffinityPriorityMap struct { // nodes contain all nodes that should be considered nodes []*v1.Node // counts store the mapping from node name to so-far computed score of // the node. counts map[string]*int64 } func newPodAffinityPriorityMap(nodes []*v1.Node) *podAffinityPriorityMap { return &podAffinityPriorityMap{ nodes: nodes, counts: make(map[string]*int64, len(nodes)), } } func (p *podAffinityPriorityMap) processTerm(term *v1.PodAffinityTerm, podDefiningAffinityTerm, podToCheck *v1.Pod, fixedNode *v1.Node, weight int64) error { namespaces := priorityutil.GetNamespacesFromPodAffinityTerm(podDefiningAffinityTerm, term) selector, err := metav1.LabelSelectorAsSelector(term.LabelSelector) if err != nil { return err } match := priorityutil.PodMatchesTermsNamespaceAndSelector(podToCheck, namespaces, selector) if match { for _, node := range p.nodes { if priorityutil.NodesHaveSameTopologyKey(node, fixedNode, term.TopologyKey) { atomic.AddInt64(p.counts[node.Name], weight) } } } return nil } func (p *podAffinityPriorityMap) processTerms(terms []v1.WeightedPodAffinityTerm, podDefiningAffinityTerm, podToCheck *v1.Pod, fixedNode *v1.Node, multiplier int) error { for i := range terms { term := &terms[i] if err := p.processTerm(&term.PodAffinityTerm, podDefiningAffinityTerm, podToCheck, fixedNode, int64(term.Weight*int32(multiplier))); err != nil { return err } } return nil } // CalculateInterPodAffinityPriority compute a sum by iterating through the elements of weightedPodAffinityTerm and adding // "weight" to the sum if the corresponding PodAffinityTerm is satisfied for // that node; the node(s) with the highest sum are the most preferred. // Symmetry need to be considered for preferredDuringSchedulingIgnoredDuringExecution from podAffinity & podAntiAffinity, // symmetry need to be considered for hard requirements from podAffinity func (ipa *InterPodAffinity) CalculateInterPodAffinityPriority(pod *v1.Pod, nodeNameToInfo map[string]*schedulernodeinfo.NodeInfo, nodes []*v1.Node) (schedulerapi.HostPriorityList, error) { affinity := pod.Spec.Affinity hasAffinityConstraints := affinity != nil && affinity.PodAffinity != nil hasAntiAffinityConstraints := affinity != nil && affinity.PodAntiAffinity != nil // priorityMap stores the mapping from node name to so-far computed score of // the node. pm := newPodAffinityPriorityMap(nodes) allNodeNames := make([]string, 0, len(nodeNameToInfo)) lazyInit := hasAffinityConstraints || hasAntiAffinityConstraints for name := range nodeNameToInfo { allNodeNames = append(allNodeNames, name) // if pod has affinity defined, or target node has affinityPods if lazyInit || len(nodeNameToInfo[name].PodsWithAffinity()) != 0 { pm.counts[name] = new(int64) } } // convert the topology key based weights to the node name based weights var maxCount, minCount int64 processPod := func(existingPod *v1.Pod) error { existingPodNode, err := ipa.info.GetNodeInfo(existingPod.Spec.NodeName) if err != nil
existingPodAffinity := existingPod.Spec.Affinity existingHasAffinityConstraints := existingPodAffinity != nil && existingPodAffinity.PodAffinity != nil existingHasAntiAffinityConstraints := existingPodAffinity != nil && existingPodAffinity.PodAntiAffinity != nil if hasAffinityConstraints { // For every soft pod affinity term of <pod>, if <existingPod> matches the term, // increment <pm.counts> for every node in the cluster with the same <term.TopologyKey> // value as that of <existingPods>`s node by the term`s weight. terms := affinity.PodAffinity.PreferredDuringSchedulingIgnoredDuringExecution if err := pm.processTerms(terms, pod, existingPod, existingPodNode, 1); err != nil { return err } } if hasAntiAffinityConstraints { // For every soft pod anti-affinity term of <pod>, if <existingPod> matches the term, // decrement <pm.counts> for every node in the cluster with the same <term.TopologyKey> // value as that of <existingPod>`s node by the term`s weight. terms := affinity.PodAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution if err := pm.processTerms(terms, pod, existingPod, existingPodNode, -1); err != nil { return err } } if existingHasAffinityConstraints { // For every hard pod affinity term of <existingPod>, if <pod> matches the term, // increment <pm.counts> for every node in the cluster with the same <term.TopologyKey> // value as that of <existingPod>'s node by the constant <ipa.hardPodAffinityWeight> if ipa.hardPodAffinityWeight > 0 { terms := existingPodAffinity.PodAffinity.RequiredDuringSchedulingIgnoredDuringExecution // TODO: Uncomment this block when implement RequiredDuringSchedulingRequiredDuringExecution. //if len(existingPodAffinity.PodAffinity.RequiredDuringSchedulingRequiredDuringExecution) != 0 { // terms = append(terms, existingPodAffinity.PodAffinity.RequiredDuringSchedulingRequiredDuringExecution...) //} for _, term := range terms { if err := pm.processTerm(&term, existingPod, pod, existingPodNode, int64(ipa.hardPodAffinityWeight)); err != nil { return err } } } // For every soft pod affinity term of <existingPod>, if <pod> matches the term, // increment <pm.counts> for every node in the cluster with the same <term.TopologyKey> // value as that of <existingPod>'s node by the term's weight. terms := existingPodAffinity.PodAffinity.PreferredDuringSchedulingIgnoredDuringExecution if err := pm.processTerms(terms, existingPod, pod, existingPodNode, 1); err != nil { return err } } if existingHasAntiAffinityConstraints { // For every soft pod anti-affinity term of <existingPod>, if <pod> matches the term, // decrement <pm.counts> for every node in the cluster with the same <term.TopologyKey> // value as that of <existingPod>'s node by the term's weight. terms := existingPodAffinity.PodAntiAffinity.PreferredDuringSchedulingIgnoredDuringExecution if err := pm.processTerms(terms, existingPod, pod, existingPodNode, -1); err != nil { return err } } return nil } errCh := schedutil.NewErrorChannel() ctx, cancel := context.WithCancel(context.Background()) processNode := func(i int) { nodeInfo := nodeNameToInfo[allNodeNames[i]] if nodeInfo.Node() != nil { if hasAffinityConstraints || hasAntiAffinityConstraints { // We need to process all the pods. for _, existingPod := range nodeInfo.Pods() { if err := processPod(existingPod); err != nil { errCh.SendErrorWithCancel(err, cancel) return } } } else { // The pod doesn't have any constraints - we need to check only existing // ones that have some. for _, existingPod := range nodeInfo.PodsWithAffinity() { if err := processPod(existingPod); err != nil { errCh.SendErrorWithCancel(err, cancel) return } } } } } workqueue.ParallelizeUntil(ctx, 16, len(allNodeNames), processNode) if err := errCh.ReceiveError(); err != nil { return nil, err } for _, node := range nodes { if pm.counts[node.Name] == nil { continue } if *pm.counts[node.Name] > maxCount { maxCount = *pm.counts[node.Name] } if *pm.counts[node.Name] < minCount { minCount = *pm.counts[node.Name] } } // calculate final priority score for each node result := make(schedulerapi.HostPriorityList, 0, len(nodes)) maxMinDiff := maxCount - minCount for _, node := range nodes { fScore := float64(0) if maxMinDiff > 0 && pm.counts[node.Name] != nil { fScore = float64(schedulerapi.MaxPriority) * (float64(*pm.counts[node.Name]-minCount) / float64(maxCount-minCount)) } result = append(result, schedulerapi.HostPriority{Host: node.Name, Score: int(fScore)}) if klog.V(10) { klog.Infof("%v -> %v: InterPodAffinityPriority, Score: (%d)", pod.Name, node.Name, int(fScore)) } } return result, nil }
{ if apierrors.IsNotFound(err) { klog.Errorf("Node not found, %v", existingPod.Spec.NodeName) return nil } return err }
lib.rs
// pub mod ed25519; pub mod mss; pub mod seed; pub mod wots; pub use seed::Seed; // TODO: documentation pub trait PrivateKeyGenerator { type PrivateKey; fn generate(&self, seed: &Seed, index: u64) -> Self::PrivateKey; } // TODO: documentation pub trait PrivateKey { type PublicKey; type Signature; fn generate_public_key(&self) -> Self::PublicKey; fn sign(&mut self, message: &[i8]) -> Self::Signature; } // TODO: documentation pub trait PublicKey { type Signature; fn verify(&self, message: &[i8], signature: &Self::Signature) -> bool; fn from_bytes(bytes: &[i8]) -> Self; fn to_bytes(&self) -> &[i8]; } // TODO: documentation pub trait Signature { fn size(&self) -> usize; fn from_bytes(bytes: &[i8]) -> Self; fn to_bytes(&self) -> &[i8]; } // TODO: documentation pub trait RecoverableSignature { type PublicKey; fn recover_public_key(&self, message: &[i8]) -> Self::PublicKey; } // TODO: remove pub fn
(xs: &[i8], ys: &[i8]) -> bool { for (x, y) in xs.iter().zip(ys.iter()) { if x != y { return false; } } true }
slice_eq
link.js
*/ CKEDITOR.dialog.add('link',function(a){var b=CKEDITOR.plugins.link,c=function(){var F=this.getDialog(),G=F.getContentElement('target','popupFeatures'),H=F.getContentElement('target','linkTargetName'),I=this.getValue();if(!G||!H)return;G=G.getElement();G.hide();H.setValue('');switch(I){case 'frame':H.setLabel(a.lang.link.targetFrameName);H.getElement().show();break;case 'popup':G.show();H.setLabel(a.lang.link.targetPopupName);H.getElement().show();break;default:H.setValue(I);H.getElement().hide();break;}},d=function(){var F=this.getDialog(),G=['urlOptions','anchorOptions','emailOptions'],H=this.getValue(),I=F.definition.getContents('upload'),J=I&&I.hidden;if(H=='url'){if(a.config.linkShowTargetTab)F.showPage('target');if(!J)F.showPage('upload');}else{F.hidePage('target');if(!J)F.hidePage('upload');}for(var K=0;K<G.length;K++){var L=F.getContentElement('info',G[K]);if(!L)continue;L=L.getElement().getParent().getParent();if(G[K]==H+'Options')L.show();else L.hide();}F.layout();},e=/^javascript:/,f=/^mailto:([^?]+)(?:\?(.+))?$/,g=/subject=([^;?:@&=$,\/]*)/,h=/body=([^;?:@&=$,\/]*)/,i=/^#(.*)$/,j=/^((?:http|https|ftp|news):\/\/)?(.*)$/,k=/^(_(?:self|top|parent|blank))$/,l=/^javascript:void\(location\.href='mailto:'\+String\.fromCharCode\(([^)]+)\)(?:\+'(.*)')?\)$/,m=/^javascript:([^(]+)\(([^)]+)\)$/,n=/\s*window.open\(\s*this\.href\s*,\s*(?:'([^']*)'|null)\s*,\s*'([^']*)'\s*\)\s*;\s*return\s*false;*\s*/,o=/(?:^|,)([^=]+)=(\d+|yes|no)/gi,p=function(F,G){var H=G&&(G.data('cke-saved-href')||G.getAttribute('href'))||'',I,J,K,L,M={};if(I=H.match(e))if(y=='encode')H=H.replace(l,function(ae,af,ag){return 'mailto:'+String.fromCharCode.apply(String,af.split(','))+(ag&&w(ag));});else if(y)H.replace(m,function(ae,af,ag){if(af==z.name){M.type='email';var ah=M.email={},ai=/[^,\s]+/g,aj=/(^')|('$)/g,ak=ag.match(ai),al=ak.length,am,an;for(var ao=0;ao<al;ao++){an=decodeURIComponent(w(ak[ao].replace(aj,'')));am=z.params[ao].toLowerCase();ah[am]=an;}ah.address=[ah.name,ah.domain].join('@');}});if(!M.type)if(K=H.match(i)){M.type='anchor';M.anchor={};M.anchor.name=M.anchor.id=K[1];}else if(J=H.match(f)){var N=H.match(g),O=H.match(h);M.type='email';var P=M.email={};P.address=J[1];N&&(P.subject=decodeURIComponent(N[1]));O&&(P.body=decodeURIComponent(O[1]));}else if(H&&(L=H.match(j))){M.type='url';M.url={};M.url.protocol=L[1];M.url.url=L[2];}else M.type='url';if(G){var Q=G.getAttribute('target');M.target={};M.adv={};if(!Q){var R=G.data('cke-pa-onclick')||G.getAttribute('onclick'),S=R&&R.match(n); if(S){M.target.type='popup';M.target.name=S[1];var T;while(T=o.exec(S[2])){if((T[2]=='yes'||T[2]=='1')&&!(T[1] in {height:1,width:1,top:1,left:1}))M.target[T[1]]=true;else if(isFinite(T[2]))M.target[T[1]]=T[2];}}}else{var U=Q.match(k);if(U)M.target.type=M.target.name=Q;else{M.target.type='frame';M.target.name=Q;}}var V=this,W=function(ae,af){var ag=G.getAttribute(af);if(ag!==null)M.adv[ae]=ag||'';};W('advId','id');W('advLangDir','dir');W('advAccessKey','accessKey');M.adv.advName=G.data('cke-saved-name')||G.getAttribute('name')||'';W('advLangCode','lang');W('advTabIndex','tabindex');W('advTitle','title');W('advContentType','type');CKEDITOR.plugins.link.synAnchorSelector?M.adv.advCSSClasses=C(G):W('advCSSClasses','class');W('advCharset','charset');W('advStyles','style');W('advRel','rel');}var X=M.anchors=[],Y;if(CKEDITOR.plugins.link.emptyAnchorFix){var Z=F.document.getElementsByTag('a');for(i=0,count=Z.count();i<count;i++){Y=Z.getItem(i);if(Y.data('cke-saved-name')||Y.hasAttribute('name'))X.push({name:Y.data('cke-saved-name')||Y.getAttribute('name'),id:Y.getAttribute('id')});}}else{var aa=new CKEDITOR.dom.nodeList(F.document.$.anchors);for(var ab=0,ac=aa.count();ab<ac;ab++){Y=aa.getItem(ab);X[ab]={name:Y.getAttribute('name'),id:Y.getAttribute('id')};}}if(CKEDITOR.plugins.link.fakeAnchor){var ad=F.document.getElementsByTag('img');for(ab=0,ac=ad.count();ab<ac;ab++){if(Y=CKEDITOR.plugins.link.tryRestoreFakeAnchor(F,ad.getItem(ab)))X.push({name:Y.getAttribute('name'),id:Y.getAttribute('id')});}}this._.selectedElement=G;return M;},q=function(F,G){if(G[F])this.setValue(G[F][this.id]||'');},r=function(F){return q.call(this,'target',F);},s=function(F){return q.call(this,'adv',F);},t=function(F,G){if(!G[F])G[F]={};G[F][this.id]=this.getValue()||'';},u=function(F){return t.call(this,'target',F);},v=function(F){return t.call(this,'adv',F);};function w(F){return F.replace(/\\'/g,"'");};function x(F){return F.replace(/'/g,'\\$&');};var y=a.config.emailProtection||'';if(y&&y!='encode'){var z={};y.replace(/^([^(]+)\(([^)]+)\)$/,function(F,G,H){z.name=G;z.params=[];H.replace(/[^,\s]+/g,function(I){z.params.push(I);});});}function A(F){var G,H=z.name,I=z.params,J,K;G=[H,'('];for(var L=0;L<I.length;L++){J=I[L].toLowerCase();K=F[J];L>0&&G.push(',');G.push("'",K?x(encodeURIComponent(F[J])):'',"'");}G.push(')');return G.join('');};function B(F){var G,H=F.length,I=[];for(var J=0;J<H;J++){G=F.charCodeAt(J);I.push(G);}return 'String.fromCharCode('+I.join(',')+')';};function C(F){var G=F.getAttribute('class'); return G?G.replace(/\s*(?:cke_anchor_empty|cke_anchor)(?:\s*$)?/g,''):'';};var D=a.lang.common,E=a.lang.link;return{title:E.title,minWidth:350,minHeight:230,contents:[{id:'info',label:E.info,title:E.info,elements:[{id:'linkType',type:'select',label:E.type,'default':'url',items:[[E.toUrl,'url'],[E.toAnchor,'anchor'],[E.toEmail,'email']],onChange:d,setup:function(F){if(F.type)this.setValue(F.type);},commit:function(F){F.type=this.getValue();}},{type:'vbox',id:'urlOptions',children:[{type:'hbox',widths:['25%','75%'],children:[{id:'protocol',type:'select',label:D.protocol,'default':'http://',items:[['http://‎','http://'],['https://‎','https://'],['ftp://‎','ftp://'],['news://‎','news://'],[E.other,'']],setup:function(F){if(F.url)this.setValue(F.url.protocol||'');},commit:function(F){if(!F.url)F.url={};F.url.protocol=this.getValue();}},{type:'text',id:'url',label:D.url,required:true,onLoad:function(){this.allowOnChange=true;},onKeyUp:function(){var K=this;K.allowOnChange=false;var F=K.getDialog().getContentElement('info','protocol'),G=K.getValue(),H=/^(http|https|ftp|news):\/\/(?=.)/i,I=/^((javascript:)|[#\/\.\?])/i,J=H.exec(G);if(J){K.setValue(G.substr(J[0].length));F.setValue(J[0].toLowerCase());}else if(I.test(G))F.setValue('');K.allowOnChange=true;},onChange:function(){if(this.allowOnChange)this.onKeyUp();},validate:function(){var F=this.getDialog();if(F.getContentElement('info','linkType')&&F.getValueOf('info','linkType')!='url')return true;if(this.getDialog().fakeObj)return true;var G=CKEDITOR.dialog.validate.notEmpty(E.noUrl);return G.apply(this);},setup:function(F){this.allowOnChange=false;if(F.url)this.setValue(F.url.url);this.allowOnChange=true;},commit:function(F){this.onChange();if(!F.url)F.url={};F.url.url=this.getValue();this.allowOnChange=false;}}],setup:function(F){if(!this.getDialog().getContentElement('info','linkType'))this.getElement().show();}},{type:'button',id:'browse',hidden:'true',filebrowser:'info:url',label:D.browseServer}]},{type:'vbox',id:'anchorOptions',width:260,align:'center',padding:0,children:[{type:'fieldset',id:'selectAnchorText',label:E.selectAnchor,setup:function(F){if(F.anchors.length>0)this.getElement().show();else this.getElement().hide();},children:[{type:'hbox',id:'selectAnchor',children:[{type:'select',id:'anchorName','default':'',label:E.anchorName,style:'width: 100%;',items:[['']],setup:function(F){var I=this;I.clear();I.add('');for(var G=0;G<F.anchors.length;G++){if(F.anchors[G].name)I.add(F.anchors[G].name);}if(F.anchor)I.setValue(F.anchor.name); var H=I.getDialog().getContentElement('info','linkType');if(H&&H.getValue()=='email')I.focus();},commit:function(F){if(!F.anchor)F.anchor={};F.anchor.name=this.getValue();}},{type:'select',id:'anchorId','default':'',label:E.anchorId,style:'width: 100%;',items:[['']],setup:function(F){var H=this;H.clear();H.add('');for(var G=0;G<F.anchors.length;G++){if(F.anchors[G].id)H.add(F.anchors[G].id);}if(F.anchor)H.setValue(F.anchor.id);},commit:function(F){if(!F.anchor)F.anchor={};F.anchor.id=this.getValue();}}],setup:function(F){if(F.anchors.length>0)this.getElement().show();else this.getElement().hide();}}]},{type:'html',id:'noAnchors',style:'text-align: center;',html:'<div role="label" tabIndex="-1">'+CKEDITOR.tools.htmlEncode(E.noAnchors)+'</div>',focus:true,setup:function(F){if(F.anchors.length<1)this.getElement().show();else this.getElement().hide();}}],setup:function(F){if(!this.getDialog().getContentElement('info','linkType'))this.getElement().hide();}},{type:'vbox',id:'emailOptions',padding:1,children:[{type:'text',id:'emailAddress',label:E.emailAddress,required:true,validate:function(){var F=this.getDialog();if(!F.getContentElement('info','linkType')||F.getValueOf('info','linkType')!='email')return true;var G=CKEDITOR.dialog.validate.notEmpty(E.noEmail);return G.apply(this);},setup:function(F){if(F.email)this.setValue(F.email.address);var G=this.getDialog().getContentElement('info','linkType');if(G&&G.getValue()=='email')this.select();},commit:function(F){if(!F.email)F.email={};F.email.address=this.getValue();}},{type:'text',id:'emailSubject',label:E.emailSubject,setup:function(F){if(F.email)this.setValue(F.email.subject);},commit:function(F){if(!F.email)F.email={};F.email.subject=this.getValue();}},{type:'textarea',id:'emailBody',label:E.emailBody,rows:3,'default':'',setup:function(F){if(F.email)this.setValue(F.email.body);},commit:function(F){if(!F.email)F.email={};F.email.body=this.getValue();}}],setup:function(F){if(!this.getDialog().getContentElement('info','linkType'))this.getElement().hide();}}]},{id:'target',label:E.target,title:E.target,elements:[{type:'hbox',widths:['50%','50%'],children:[{type:'select',id:'linkTargetType',label:D.target,'default':'notSet',style:'width : 100%;',items:[[D.notSet,'notSet'],[E.targetFrame,'frame'],[E.targetPopup,'popup'],[D.targetNew,'_blank'],[D.targetTop,'_top'],[D.targetSelf,'_self'],[D.targetParent,'_parent']],onChange:c,setup:function(F){if(F.target)this.setValue(F.target.type||'notSet');c.call(this);},commit:function(F){if(!F.target)F.target={}; F.target.type=this.getValue();}},{type:'text',id:'linkTargetName',label:E.targetFrameName,'default':'',setup:function(F){if(F.target)this.setValue(F.target.name);},commit:function(F){if(!F.target)F.target={};F.target.name=this.getValue().replace(/\W/gi,'');}}]},{type:'vbox',width:'100%',align:'center',padding:2,id:'popupFeatures',children:[{type:'fieldset',label:E.popupFeatures,children:[{type:'hbox',children:[{type:'checkbox',id:'resizable',label:E.popupResizable,setup:r,commit:u},{type:'checkbox',id:'status',label:E.popupStatusBar,setup:r,commit:u}]},{type:'hbox',children:[{type:'checkbox',id:'location',label:E.popupLocationBar,setup:r,commit:u},{type:'checkbox',id:'toolbar',label:E.popupToolbar,setup:r,commit:u}]},{type:'hbox',children:[{type:'checkbox',id:'menubar',label:E.popupMenuBar,setup:r,commit:u},{type:'checkbox',id:'fullscreen',label:E.popupFullScreen,setup:r,commit:u}]},{type:'hbox',children:[{type:'checkbox',id:'scrollbars',label:E.popupScrollBars,setup:r,commit:u},{type:'checkbox',id:'dependent',label:E.popupDependent,setup:r,commit:u}]},{type:'hbox',children:[{type:'text',widths:['50%','50%'],labelLayout:'horizontal',label:D.width,id:'width',setup:r,commit:u},{type:'text',labelLayout:'horizontal',widths:['50%','50%'],label:E.popupLeft,id:'left',setup:r,commit:u}]},{type:'hbox',children:[{type:'text',labelLayout:'horizontal',widths:['50%','50%'],label:D.height,id:'height',setup:r,commit:u},{type:'text',labelLayout:'horizontal',label:E.popupTop,widths:['50%','50%'],id:'top',setup:r,commit:u}]}]}]}]},{id:'upload',label:E.upload,title:E.upload,hidden:true,filebrowser:'uploadButton',elements:[{type:'file',id:'upload',label:D.upload,style:'height:40px',size:29},{type:'fileButton',id:'uploadButton',label:D.uploadSubmit,filebrowser:'info:url','for':['upload','upload']}]},{id:'advanced',label:E.advanced,title:E.advanced,elements:[{type:'vbox',padding:1,children:[{type:'hbox',widths:['45%','35%','20%'],children:[{type:'text',id:'advId',label:E.id,setup:s,commit:v},{type:'select',id:'advLangDir',label:E.langDir,'default':'',style:'width:110px',items:[[D.notSet,''],[E.langDirLTR,'ltr'],[E.langDirRTL,'rtl']],setup:s,commit:v},{type:'text',id:'advAccessKey',width:'80px',label:E.acccessKey,maxLength:1,setup:s,commit:v}]},{type:'hbox',widths:['45%','35%','20%'],children:[{type:'text',label:E.name,id:'advName',setup:s,commit:v},{type:'text',label:E.langCode,id:'advLangCode',width:'110px','default':'',setup:s,commit:v},{type:'text',label:E.tabIndex,id:'advTabIndex',width:'80px',maxLength:5,setup:s,commit:v}]}]},{type:'vbox',padding:1,children:[{type:'hbox',widths:['45%','55%'],children:[{type:'text',label:E.advisoryTitle,'default':'',id:'advTitle',setup:s,commit:v},{type:'text',label:E.advisoryContentType,'default':'',id:'advContentType',setup:s,commit:v}]},{type:'hbox',widths:['45%','55%'],children:[{type:'text',label:E.cssClasses,'default':'',id:'advCSSClasses',setup:s,commit:v},{type:'text',label:E.charset,'default':'',id:'advCharset',setup:s,commit:v}]},{type:'hbox',widths:['45%','55%'],children:[{type:'text',label:E.rel,'default':'',id:'advRel',setup:s,commit:v},{type:'text',label:E.styles,'default':'',id:'advStyles',validate:CKEDITOR.dialog.validate.inlineStyle(a.lang.common.invalidInlineStyle),setup:s,commit:v}]}]}]}],onShow:function(){var F=this.getParentEditor(),G=F.getSelection(),H=null; if((H=b.getSelectedLink(F))&&H.hasAttribute('href'))G.selectElement(H);else H=null;this.setupContent(p.apply(this,[F,H]));},onOk:function(){var F={},G=[],H={},I=this,J=this.getParentEditor();this.commitContent(H);switch(H.type||'url'){case 'url':var K=H.url&&H.url.protocol!=undefined?H.url.protocol:'http://',L=H.url&&CKEDITOR.tools.trim(H.url.url)||'';F['data-cke-saved-href']=L.indexOf('/')===0?L:K+L;break;case 'anchor':var M=H.anchor&&H.anchor.name,N=H.anchor&&H.anchor.id;F['data-cke-saved-href']='#'+(M||N||'');break;case 'email':var O,P=H.email,Q=P.address;switch(y){case '':case 'encode':var R=encodeURIComponent(P.subject||''),S=encodeURIComponent(P.body||''),T=[];R&&T.push('subject='+R);S&&T.push('body='+S);T=T.length?'?'+T.join('&'):'';if(y=='encode'){O=["javascript:void(location.href='mailto:'+",B(Q)];T&&O.push("+'",x(T),"'");O.push(')');}else O=['mailto:',Q,T];break;default:var U=Q.split('@',2);P.name=U[0];P.domain=U[1];O=['javascript:',A(P)];}F['data-cke-saved-href']=O.join('');break;}if(H.target)if(H.target.type=='popup'){var V=["window.open(this.href, '",H.target.name||'',"', '"],W=['resizable','status','location','toolbar','menubar','fullscreen','scrollbars','dependent'],X=W.length,Y=function(ai){if(H.target[ai])W.push(ai+'='+H.target[ai]);};for(var Z=0;Z<X;Z++)W[Z]=W[Z]+(H.target[W[Z]]?'=yes':'=no');Y('width');Y('left');Y('height');Y('top');V.push(W.join(','),"'); return false;");F['data-cke-pa-onclick']=V.join('');G.push('target');}else{if(H.target.type!='notSet'&&H.target.name)F.target=H.target.name;else G.push('target');G.push('data-cke-pa-onclick','onclick');}if(H.adv){var aa=function(ai,aj){var ak=H.adv[ai];if(ak)F[aj]=ak;else G.push(aj);};aa('advId','id');aa('advLangDir','dir');aa('advAccessKey','accessKey');if(H.adv.advName)F.name=F['data-cke-saved-name']=H.adv.advName;else G=G.concat(['data-cke-saved-name','name']);aa('advLangCode','lang');aa('advTabIndex','tabindex');aa('advTitle','title');aa('advContentType','type');aa('advCSSClasses','class');aa('advCharset','charset');aa('advStyles','style');aa('advRel','rel');}F.href=F['data-cke-saved-href'];if(!this._.selectedElement){var ab=J.getSelection(),ac=ab.getRanges(true);if(ac.length==1&&ac[0].collapsed){var ad=new CKEDITOR.dom.text(H.type=='email'?H.email.address:F['data-cke-saved-href'],J.document);ac[0].insertNode(ad);ac[0].selectNodeContents(ad);ab.selectRanges(ac);}var ae=new CKEDITOR.style({element:'a',attributes:F});ae.type=CKEDITOR.STYLE_INLINE;ae.apply(J.document);}else{var af=this._.selectedElement,ag=af.data('cke-saved-href'),ah=af.getHtml(); af.setAttributes(F);af.removeAttributes(G);if(H.adv&&H.adv.advName&&CKEDITOR.plugins.link.synAnchorSelector)af.addClass(af.getChildCount()?'cke_anchor':'cke_anchor_empty');if(ag==ah||H.type=='email'&&ah.indexOf('@')!=-1)af.setHtml(H.type=='email'?H.email.address:F['data-cke-saved-href']);delete this._.selectedElement;}},onLoad:function(){if(!a.config.linkShowAdvancedTab)this.hidePage('advanced');if(!a.config.linkShowTargetTab)this.hidePage('target');},onFocus:function(){var F=this.getContentElement('info','linkType'),G;if(F&&F.getValue()=='url'){G=this.getContentElement('info','url');G.select();}}};});
/* Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved. For licensing, see LICENSE.html or http://ckeditor.com/license
idscheme.go
// Copyright 2018 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // The go-ethereum library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. package enode import ( "crypto/ecdsa" "fmt" "io" "github.com/MetisProtocol/l2geth/common/math" "github.com/MetisProtocol/l2geth/crypto" "github.com/MetisProtocol/l2geth/p2p/enr" "github.com/MetisProtocol/l2geth/rlp" "golang.org/x/crypto/sha3" ) // List of known secure identity schemes. var ValidSchemes = enr.SchemeMap{ "v4": V4ID{}, } var ValidSchemesForTesting = enr.SchemeMap{ "v4": V4ID{}, "null": NullID{}, } // v4ID is the "v4" identity scheme. type V4ID struct{} // SignV4 signs a record using the v4 scheme. func SignV4(r *enr.Record, privkey *ecdsa.PrivateKey) error { // Copy r to avoid modifying it if signing fails. cpy := *r cpy.Set(enr.ID("v4")) cpy.Set(Secp256k1(privkey.PublicKey)) h := sha3.NewLegacyKeccak256() rlp.Encode(h, cpy.AppendElements(nil)) sig, err := crypto.Sign(h.Sum(nil), privkey) if err != nil { return err } sig = sig[:len(sig)-1] // remove v if err = cpy.SetSig(V4ID{}, sig); err == nil { *r = cpy } return err } func (V4ID) Verify(r *enr.Record, sig []byte) error { var entry s256raw if err := r.Load(&entry); err != nil { return err } else if len(entry) != 33 { return fmt.Errorf("invalid public key") } h := sha3.NewLegacyKeccak256() rlp.Encode(h, r.AppendElements(nil)) if !crypto.VerifySignature(entry, h.Sum(nil), sig) { return enr.ErrInvalidSig } return nil } func (V4ID) NodeAddr(r *enr.Record) []byte { var pubkey Secp256k1 err := r.Load(&pubkey) if err != nil { return nil } buf := make([]byte, 64) math.ReadBits(pubkey.X, buf[:32]) math.ReadBits(pubkey.Y, buf[32:]) return crypto.Keccak256(buf) } // Secp256k1 is the "secp256k1" key, which holds a public key. type Secp256k1 ecdsa.PublicKey func (v Secp256k1) ENRKey() string { return "secp256k1" } // EncodeRLP implements rlp.Encoder. func (v Secp256k1) EncodeRLP(w io.Writer) error { return rlp.Encode(w, crypto.CompressPubkey((*ecdsa.PublicKey)(&v))) } // DecodeRLP implements rlp.Decoder. func (v *Secp256k1) DecodeRLP(s *rlp.Stream) error { buf, err := s.Bytes() if err != nil { return err } pk, err := crypto.DecompressPubkey(buf) if err != nil { return err } *v = (Secp256k1)(*pk) return nil } // s256raw is an unparsed secp256k1 public key entry. type s256raw []byte func (s256raw) ENRKey() string { return "secp256k1" } // v4CompatID is a weaker and insecure version of the "v4" scheme which only checks for the // presence of a secp256k1 public key, but doesn't verify the signature. type v4CompatID struct { V4ID } func (v4CompatID) Verify(r *enr.Record, sig []byte) error { var pubkey Secp256k1 return r.Load(&pubkey) } func signV4Compat(r *enr.Record, pubkey *ecdsa.PublicKey)
// NullID is the "null" ENR identity scheme. This scheme stores the node // ID in the record without any signature. type NullID struct{} func (NullID) Verify(r *enr.Record, sig []byte) error { return nil } func (NullID) NodeAddr(r *enr.Record) []byte { var id ID r.Load(enr.WithEntry("nulladdr", &id)) return id[:] } func SignNull(r *enr.Record, id ID) *Node { r.Set(enr.ID("null")) r.Set(enr.WithEntry("nulladdr", id)) if err := r.SetSig(NullID{}, []byte{}); err != nil { panic(err) } return &Node{r: *r, id: id} }
{ r.Set((*Secp256k1)(pubkey)) if err := r.SetSig(v4CompatID{}, []byte{}); err != nil { panic(err) } }
main.go
/* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package main import ( "os" "github.com/richardcase/itsrandomoperator/pkg/apis" "github.com/richardcase/itsrandomoperator/pkg/controller" _ "k8s.io/client-go/plugin/pkg/client/auth/gcp" "sigs.k8s.io/controller-runtime/pkg/client/config" "sigs.k8s.io/controller-runtime/pkg/manager" logf "sigs.k8s.io/controller-runtime/pkg/runtime/log" "sigs.k8s.io/controller-runtime/pkg/runtime/signals" ) func main() { logf.SetLogger(logf.ZapLogger(false)) log := logf.Log.WithName("entrypoint") namespace := os.Getenv("POD_NAMESPACE") if len(namespace) == 0 { log.Info("must set env POD_NAMESPACE") return } // Get a config to talk to the apiserver log.Info("setting up client for manager") cfg, err := config.GetConfig() if err != nil { log.Error(err, "unable to set up client config") os.Exit(1) } // Create a new Cmd to provide shared dependencies and start components log.Info("setting up manager") mgr, err := manager.New(cfg, manager.Options{ LeaderElection: true, LeaderElectionID: "rpa-operator", LeaderElectionNamespace: namespace, }) if err != nil
log.Info("Registering Components.") // Setup Scheme for all resources log.Info("setting up scheme") if err := apis.AddToScheme(mgr.GetScheme()); err != nil { log.Error(err, "unable add APIs to scheme") os.Exit(1) } // Setup all Controllers log.Info("Setting up controller") if err := controller.AddToManager(mgr); err != nil { log.Error(err, "unable to register controllers to the manager") os.Exit(1) } // Start the Cmd log.Info("Starting the Cmd.") if err := mgr.Start(signals.SetupSignalHandler()); err != nil { log.Error(err, "unable to run the manager") os.Exit(1) } }
{ log.Error(err, "unable to set up overall controller manager") os.Exit(1) }
main.rs
extern crate postgres; extern crate rand; extern crate time; extern crate csv; use postgres::{Connection, SslMode}; use std::env::{var_os}; use time::{precise_time_ns, now_utc}; use rand::{random}; use std::cmp::{min}; use std::thread::{sleep_ms}; use std::io::{stdout,Write}; use csv::Writer; struct RingBuffer { d: Vec<(f64, f64)>, size: usize, pos:usize } fn update (r: RingBuffer, value: (f64, f64)) -> RingBuffer { let p = r.pos % r.size; if r.d.len() > p { let mut d = r.d.clone(); d[p] = value; let d1 = d; RingBuffer{d:d1,size:r.size,pos:p+1} } else { let mut d = r.d.clone(); d.push(value); let d1 = d; RingBuffer{d:d1,size:r.size,pos:p+1} } } fn pair_wise_mean (v: &Vec<(f64, f64)>) -> (f64, f64) { let mut xsum = 0.0f64; let mut ysum = 0.0f64; for i in 0..v.len() { xsum = xsum + v[i].0; ysum = ysum + v[i].1; } (xsum/(v.len() as f64), ysum/(v.len() as f64)) } fn least_squares_line_of_best_fit (pairs: Vec<(f64, f64)>) -> (f64, f64)
fn x_intercept (m: f64, b: f64) -> f64 { (0f64 - b) / m } fn main () { match (var_os("URL"), var_os("QUERY"), var_os("BUFFER"), var_os("INTERVAL")) { (Some(url), Some(query), Some(buffer_size_s), Some(interval_s)) => { let conn = Connection::connect(url.to_str().unwrap(), &SslMode::None).unwrap(); let stmt = conn.prepare(query.to_str().unwrap()).unwrap(); let mut r = RingBuffer{d:Vec::new(), size: buffer_size_s.to_str().unwrap().parse::<usize>().unwrap(), pos: 0}; let mut i = 0; loop { let mut w = Writer::from_memory().delimiter(b'\t'); if (i % 20) == 0 { w.encode(("time", "recent-x", "recent-y", "x-intercept", "y-intercept", "m")).ok().unwrap(); } for row in stmt.query(&[]).unwrap() { let x = row.get(0); let y = row.get(1); r = update(r, (x,y)); if i > 2 { let (m, b) = least_squares_line_of_best_fit(r.d.clone()); w.encode((now_utc().rfc3339().to_string(), x, y, x_intercept(m, b), b, m)).ok().unwrap(); } }; stdout().write_all(w.as_bytes()).ok().unwrap(); sleep_ms(interval_s.to_str().unwrap().parse::<u32>().unwrap()); i = i + 1 } }, _ => println!("Be sure to define URL, QUERY, BUFFER, and INTERVAL") } }
{ let ref p = pairs; let means = pair_wise_mean(p); let mut t = 0f64; let mut u = 0f64; let l = p.len(); for i in 0..l { t = ((pairs[i].0 - means.0) * (pairs[i].1 - means.1)) + t; u = ((pairs[i].0 - means.0) * (pairs[i].0 - means.0)) + u; } let m = t/u; let b = means.1 - (m * means.0); (m, b) }
008_Add_deleted_flag_to_batch.py
from sqlalchemy import MetaData, Table, Column, Boolean meta = MetaData() def upgrade(migrate_engine): meta = MetaData(bind=migrate_engine) batch = Table("batch", meta, autoload=True) deleted = Column("deleted", Boolean()) deleted.create(batch) def downgrade(migrate_engine):
meta = MetaData(bind=migrate_engine) batch = Table("batch", meta, autoload=True) batch.c.deleted.drop()
networkSecurityGroupsUpdateTagsSample.ts
/* * Copyright (c) Microsoft Corporation. * Licensed under the MIT License. * * Code generated by Microsoft (R) AutoRest Code Generator. * Changes may cause incorrect behavior and will be lost if the code is regenerated. */ // Copyright (c) Microsoft Corporation. // Licensed under the MIT License. import { TagsObject, NetworkManagementClient } from "@azure/arm-network"; import { DefaultAzureCredential } from "@azure/identity"; /** * This sample demonstrates how to Updates a network security group tags. * * @summary Updates a network security group tags. * x-ms-original-file: specification/network/resource-manager/Microsoft.Network/stable/2021-05-01/examples/NetworkSecurityGroupUpdateTags.json */ async function updateNetworkSecurityGroupTags() { const subscriptionId = "subid";
const credential = new DefaultAzureCredential(); const client = new NetworkManagementClient(credential, subscriptionId); const result = await client.networkSecurityGroups.updateTags( resourceGroupName, networkSecurityGroupName, parameters ); console.log(result); } updateNetworkSecurityGroupTags().catch(console.error);
const resourceGroupName = "rg1"; const networkSecurityGroupName = "testnsg"; const parameters: TagsObject = { tags: { tag1: "value1", tag2: "value2" } };