From a7424724651f6eeb41efffb4e8d6d4dc44466804 Mon Sep 17 00:00:00 2001 From: Nicholas Molnar <65710+neekolas@users.noreply.github.com> Date: Sun, 16 Apr 2023 14:23:25 -0700 Subject: [PATCH] Simplify proto gen (#52) * Initial commit * Include lib * Add features * Correct import * Add feature * Add pbjson * Almost passing * Add build.rs * Add .gitignore * Rename folder * Remove generated code * Gitignore generated * Automatically install required dependency --- .gitignore | 4 + Cargo.lock | 2161 +++++++ Cargo.toml | 9 + bindings/xmtp_rust_swift/.gitignore | 1 + bindings/xmtp_rust_swift/src/lib.rs | 2 +- crates/Cargo.lock | 39 + crates/Cargo.toml | 7 - crates/xmtp-networking/Cargo.toml | 8 +- crates/xmtp-networking/build.rs | 46 - crates/xmtp-networking/proto/googleapis | 1 - .../proto/keystore_api/v1/keystore.proto | 186 - .../proto/message_api/v1/authn.proto | 32 - .../proto/message_api/v1/message_api.proto | 137 - .../proto/message_contents/ciphertext.proto | 45 - .../proto/message_contents/composite.proto | 22 - .../proto/message_contents/contact.proto | 32 - .../proto/message_contents/content.proto | 55 - .../proto/message_contents/invitation.proto | 72 - .../proto/message_contents/message.proto | 71 - .../proto/message_contents/private_key.proto | 95 - .../proto/message_contents/public_key.proto | 67 - .../proto/message_contents/signature.proto | 29 - crates/xmtp-networking/src/google.api.rs | 375 -- crates/xmtp-networking/src/grpc_api_helper.rs | 2 +- crates/xmtp-networking/src/lib.rs | 8 +- crates/xmtp-networking/src/proto_helper.rs | 15 - .../src/xmtp.keystore_api.v1.rs | 388 -- .../src/xmtp.message_api.v1.rs | 812 --- .../src/xmtp.message_contents.rs | 727 --- crates/xmtp-proto/.gitignore | 1 + crates/xmtp-proto/Cargo.toml | 25 + crates/xmtp-proto/buf.gen.yaml | 24 + crates/xmtp-proto/build.rs | 42 + crates/xmtp-proto/src/gen/mod.rs | 25 + .../src/gen/xmtp.keystore_api.v1.rs | 904 +++ .../src/gen/xmtp.keystore_api.v1.serde.rs | 2867 +++++++++ .../xmtp-proto/src/gen/xmtp.message_api.v1.rs | 639 ++ .../src/gen/xmtp.message_api.v1.serde.rs | 1554 +++++ .../src/gen/xmtp.message_api.v1.tonic.rs | 173 + .../src/gen/xmtp.message_contents.rs | 2295 ++++++++ .../src/gen/xmtp.message_contents.serde.rs | 5198 +++++++++++++++++ crates/xmtp-proto/src/lib.rs | 9 + 42 files changed, 15981 insertions(+), 3223 deletions(-) create mode 100644 Cargo.lock create mode 100644 Cargo.toml delete mode 100644 crates/Cargo.toml delete mode 100644 crates/xmtp-networking/build.rs delete mode 160000 crates/xmtp-networking/proto/googleapis delete mode 100644 crates/xmtp-networking/proto/keystore_api/v1/keystore.proto delete mode 100644 crates/xmtp-networking/proto/message_api/v1/authn.proto delete mode 100644 crates/xmtp-networking/proto/message_api/v1/message_api.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/ciphertext.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/composite.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/contact.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/content.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/invitation.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/message.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/private_key.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/public_key.proto delete mode 100644 crates/xmtp-networking/proto/message_contents/signature.proto delete mode 100644 crates/xmtp-networking/src/google.api.rs delete mode 100644 crates/xmtp-networking/src/proto_helper.rs delete mode 100644 crates/xmtp-networking/src/xmtp.keystore_api.v1.rs delete mode 100644 crates/xmtp-networking/src/xmtp.message_api.v1.rs delete mode 100644 crates/xmtp-networking/src/xmtp.message_contents.rs create mode 100644 crates/xmtp-proto/.gitignore create mode 100644 crates/xmtp-proto/Cargo.toml create mode 100644 crates/xmtp-proto/buf.gen.yaml create mode 100644 crates/xmtp-proto/build.rs create mode 100644 crates/xmtp-proto/src/gen/mod.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.serde.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.message_api.v1.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.message_api.v1.serde.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.message_api.v1.tonic.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.message_contents.rs create mode 100644 crates/xmtp-proto/src/gen/xmtp.message_contents.serde.rs create mode 100644 crates/xmtp-proto/src/lib.rs diff --git a/.gitignore b/.gitignore index d8adecc2a..521b43cec 100644 --- a/.gitignore +++ b/.gitignore @@ -124,3 +124,7 @@ dist # Swap files for vim *.swp *.swo + + +# Generated code +crates/xmtp_proto/src/gen \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 000000000..620ca9d97 --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,2161 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "433cfd6710c9986c576a25ca913c39d66a6474107b406f34f91d4a8923395241" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "aes-gcm" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82e1366e0c69c9f927b1fa5ce2c7bf9eafc8f9268c0b9800729e8b267612447c" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "ghash", + "subtle", +] + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.70" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7de8ce5e0f9f8d88245311066a578d72b7af3e7088f32783804676302df237e4" + +[[package]] +name = "async-stream" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "async-trait" +version = "0.1.68" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "autocfg" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" + +[[package]] +name = "axum" +version = "0.6.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b32c5ea3aabaf4deb5f5ced2d688ec0844c881c9e6c696a8b769a05fc691e62" +dependencies = [ + "async-trait", + "axum-core", + "bitflags", + "bytes", + "futures-util", + "http", + "http-body", + "hyper", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "sync_wrapper", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "axum-core" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "759fa577a247914fd3f7f76d62972792636412fbfd634cd452f6a385a74d2d2c" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http", + "http-body", + "mime", + "rustversion", + "tower-layer", + "tower-service", +] + +[[package]] +name = "base16ct" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce" + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "base64" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a" + +[[package]] +name = "base64ct" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bumpalo" +version = "3.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535" + +[[package]] +name = "bytes" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be" + +[[package]] +name = "cc" +version = "1.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "chrono" +version = "0.4.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e3c5919066adf22df73762e50cffcde3a758f2a848b113b586d1f86728b673b" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-integer", + "num-traits", + "time", + "wasm-bindgen", + "winapi", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + +[[package]] +name = "codespan-reporting" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e" +dependencies = [ + "termcolor", + "unicode-width", +] + +[[package]] +name = "const-oid" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913" + +[[package]] +name = "core-foundation-sys" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" + +[[package]] +name = "corecrypto" +version = "0.1.0" +dependencies = [ + "aes-gcm", + "chrono", + "ecdsa", + "generic-array", + "getrandom", + "hex", + "hkdf", + "k256", + "rand", + "rlp", + "sha2", + "sha3", +] + +[[package]] +name = "cpufeatures" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "280a9f2d8b3a38871a3c8a46fb80db65e5e5ed97da80c4d08bf27fb63e35e181" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-bigint" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef" +dependencies = [ + "generic-array", + "rand_core", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +dependencies = [ + "generic-array", + "rand_core", + "typenum", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "cxx" +version = "1.0.94" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f61f1b6389c3fe1c316bf8a4dccc90a38208354b330925bce1f74a6c4756eb93" +dependencies = [ + "cc", + "cxxbridge-flags", + "cxxbridge-macro", + "link-cplusplus", +] + +[[package]] +name = "cxx-build" +version = "1.0.94" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12cee708e8962df2aeb38f594aae5d827c022b6460ac71a7a3e2c3c2aae5a07b" +dependencies = [ + "cc", + "codespan-reporting", + "once_cell", + "proc-macro2", + "quote", + "scratch", + "syn 2.0.15", +] + +[[package]] +name = "cxxbridge-flags" +version = "1.0.94" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7944172ae7e4068c533afbb984114a56c46e9ccddda550499caa222902c7f7bb" + +[[package]] +name = "cxxbridge-macro" +version = "1.0.94" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2345488264226bf682893e25de0769f3360aac9957980ec49361b083ddaa5bc5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "der" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de" +dependencies = [ + "const-oid", + "zeroize", +] + +[[package]] +name = "digest" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "ecdsa" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12844141594ad74185a926d030f3b605f6a903b4e3fec351f3ea338ac5b7637e" +dependencies = [ + "der", + "elliptic-curve", + "rfc6979", + "signature", +] + +[[package]] +name = "either" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" + +[[package]] +name = "elliptic-curve" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3" +dependencies = [ + "base16ct", + "crypto-bigint", + "der", + "digest", + "ff", + "generic-array", + "group", + "hkdf", + "pkcs8", + "rand_core", + "sec1", + "subtle", + "zeroize", +] + +[[package]] +name = "errno" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a" +dependencies = [ + "errno-dragonfly", + "libc", + "windows-sys 0.48.0", +] + +[[package]] +name = "errno-dragonfly" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf" +dependencies = [ + "cc", + "libc", +] + +[[package]] +name = "fastrand" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be" +dependencies = [ + "instant", +] + +[[package]] +name = "ff" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160" +dependencies = [ + "rand_core", + "subtle", +] + +[[package]] +name = "fixedbitset" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "futures-channel" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c" + +[[package]] +name = "futures-sink" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e" + +[[package]] +name = "futures-task" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65" + +[[package]] +name = "futures-util" +version = "0.3.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "pin-utils", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi 0.11.0+wasi-snapshot-preview1", + "wasm-bindgen", +] + +[[package]] +name = "ghash" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40" +dependencies = [ + "opaque-debug", + "polyval", +] + +[[package]] +name = "group" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + +[[package]] +name = "h2" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66b91535aa35fea1523ad1b86cb6b53c28e0ae566ba4a460f4457e936cad7c6f" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + +[[package]] +name = "hermit-abi" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7" +dependencies = [ + "libc", +] + +[[package]] +name = "hermit-abi" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hkdf" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437" +dependencies = [ + "hmac", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "http" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "http-body" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" +dependencies = [ + "bytes", + "http", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" + +[[package]] +name = "httpdate" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421" + +[[package]] +name = "hyper" +version = "0.14.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab302d72a6f11a3b910431ff93aae7e773078c769f0a3ef15fb9ec692ed147d4" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", + "want", +] + +[[package]] +name = "hyper-timeout" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1" +dependencies = [ + "hyper", + "pin-project-lite", + "tokio", + "tokio-io-timeout", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0722cd7114b7de04316e7ea5456a0bbb20e4adb46fd27a3697adb812cff0f37c" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "wasm-bindgen", + "windows", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca" +dependencies = [ + "cxx", + "cxx-build", +] + +[[package]] +name = "indexmap" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" +dependencies = [ + "autocfg", + "hashbrown", +] + +[[package]] +name = "inout" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5" +dependencies = [ + "generic-array", +] + +[[package]] +name = "instant" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "io-lifetimes" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220" +dependencies = [ + "hermit-abi 0.3.1", + "libc", + "windows-sys 0.48.0", +] + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6" + +[[package]] +name = "js-sys" +version = "0.3.61" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "k256" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92a55e0ff3b72c262bcf041d9e97f1b84492b68f1c1a384de2323d3dc9403397" +dependencies = [ + "cfg-if", + "ecdsa", + "elliptic-curve", + "once_cell", + "sha2", + "signature", +] + +[[package]] +name = "keccak" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768" +dependencies = [ + "cpufeatures", +] + +[[package]] +name = "lazy_static" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" + +[[package]] +name = "libc" +version = "0.2.141" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5" + +[[package]] +name = "link-cplusplus" +version = "1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5" +dependencies = [ + "cc", +] + +[[package]] +name = "linux-raw-sys" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f" + +[[package]] +name = "lock_api" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df" +dependencies = [ + "autocfg", + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "matchit" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b87248edafb776e59e6ee64a79086f65890d3510f2c656c000bf2a7e8a0aea40" + +[[package]] +name = "memchr" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "mio" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9" +dependencies = [ + "libc", + "log", + "wasi 0.11.0+wasi-snapshot-preview1", + "windows-sys 0.45.0", +] + +[[package]] +name = "multimap" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a" + +[[package]] +name = "num-integer" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_cpus" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b" +dependencies = [ + "hermit-abi 0.2.6", + "libc", +] + +[[package]] +name = "once_cell" +version = "1.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3" + +[[package]] +name = "opaque-debug" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" + +[[package]] +name = "parking_lot" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.2.16", + "smallvec", + "windows-sys 0.45.0", +] + +[[package]] +name = "pbjson" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "048f9ac93c1eab514f9470c4bc8d97ca2a0a236b84f45cc19d69a59fc11467f6" +dependencies = [ + "base64 0.13.1", + "serde", +] + +[[package]] +name = "pbjson-build" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdbb7b706f2afc610f3853550cdbbf6372fd324824a087806bd4480ea4996e24" +dependencies = [ + "heck", + "itertools", + "prost", + "prost-types", +] + +[[package]] +name = "pbjson-types" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a88c8d87f99a4ac14325e7a4c24af190fca261956e3b82dd7ed67e77e6c7043" +dependencies = [ + "bytes", + "chrono", + "pbjson", + "pbjson-build", + "prost", + "prost-build", + "serde", +] + +[[package]] +name = "percent-encoding" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e" + +[[package]] +name = "petgraph" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dd7d28ee937e54fe3080c91faa1c3a46c06de6252988a7f4592ba2310ef22a4" +dependencies = [ + "fixedbitset", + "indexmap", +] + +[[package]] +name = "pin-project" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pkcs8" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba" +dependencies = [ + "der", + "spki", +] + +[[package]] +name = "polyval" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ef234e08c11dfcb2e56f79fd70f6f2eb7f025c0ce2333e82f4f0518ecad30c6" +dependencies = [ + "cfg-if", + "cpufeatures", + "opaque-debug", + "universal-hash", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + +[[package]] +name = "proc-macro2" +version = "1.0.56" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "prost" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-build" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f835c582e6bd972ba8347313300219fed5bfa52caf175298d860b61ff6069bb" +dependencies = [ + "bytes", + "heck", + "itertools", + "lazy_static", + "log", + "multimap", + "petgraph", + "prost", + "prost-types", + "regex", + "tempfile", + "which", +] + +[[package]] +name = "prost-derive" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4" +dependencies = [ + "anyhow", + "itertools", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "prost-types" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13" +dependencies = [ + "prost", +] + +[[package]] +name = "protobuf" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b55bad9126f378a853655831eb7363b7b01b81d19f8cb1218861086ca4a1a61e" +dependencies = [ + "once_cell", + "protobuf-support", + "thiserror", +] + +[[package]] +name = "protobuf-support" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5d4d7b8601c814cfb36bcebb79f0e61e45e1e93640cf778837833bbed05c372" +dependencies = [ + "thiserror", +] + +[[package]] +name = "quote" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + +[[package]] +name = "redox_syscall" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_syscall" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29" +dependencies = [ + "bitflags", +] + +[[package]] +name = "regex" +version = "1.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d" +dependencies = [ + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + +[[package]] +name = "rfc6979" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb" +dependencies = [ + "crypto-bigint", + "hmac", + "zeroize", +] + +[[package]] +name = "ring" +version = "0.16.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" +dependencies = [ + "cc", + "libc", + "once_cell", + "spin", + "untrusted", + "web-sys", + "winapi", +] + +[[package]] +name = "rlp" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec" +dependencies = [ + "bytes", + "rustc-hex", +] + +[[package]] +name = "rustc-hex" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" + +[[package]] +name = "rustix" +version = "0.37.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85597d61f83914ddeba6a47b3b8ffe7365107221c2e557ed94426489fefb5f77" +dependencies = [ + "bitflags", + "errno", + "io-lifetimes", + "libc", + "linux-raw-sys", + "windows-sys 0.48.0", +] + +[[package]] +name = "rustls" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07180898a28ed6a7f7ba2311594308f595e3dd2e3c3812fa0a80a47b45f17e5d" +dependencies = [ + "log", + "ring", + "rustls-webpki", + "sct", +] + +[[package]] +name = "rustls-webpki" +version = "0.100.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6207cd5ed3d8dca7816f8f3725513a34609c0c765bf652b8c3cb4cfd87db46b" +dependencies = [ + "ring", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06" + +[[package]] +name = "ryu" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041" + +[[package]] +name = "scopeguard" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" + +[[package]] +name = "scratch" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1" + +[[package]] +name = "sct" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4" +dependencies = [ + "ring", + "untrusted", +] + +[[package]] +name = "sec1" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928" +dependencies = [ + "base16ct", + "der", + "generic-array", + "pkcs8", + "subtle", + "zeroize", +] + +[[package]] +name = "serde" +version = "1.0.160" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.160" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291a097c63d8497e00160b166a967a4a79c64f3facdd01cbd7502231688d77df" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "serde_json" +version = "1.0.96" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sha2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sha3" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54c2bb1a323307527314a36bfb73f24febb08ce2b8a554bf4ffd6f51ad15198c" +dependencies = [ + "digest", + "keccak", +] + +[[package]] +name = "signal-hook-registry" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" +dependencies = [ + "libc", +] + +[[package]] +name = "signature" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fe458c98333f9c8152221191a77e2a44e8325d0193484af2e9421a53019e57d" +dependencies = [ + "digest", + "rand_core", +] + +[[package]] +name = "slab" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d" +dependencies = [ + "autocfg", +] + +[[package]] +name = "smallvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0" + +[[package]] +name = "socket2" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "spin" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" + +[[package]] +name = "spki" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b" +dependencies = [ + "base64ct", + "der", +] + +[[package]] +name = "subtle" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601" + +[[package]] +name = "swift-bridge" +version = "0.1.51" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8fa07c7cd2b2d7ca48d96f5abd159e3fd3eee3457e7bd03adc1994bfbdabd2f" +dependencies = [ + "once_cell", + "swift-bridge-build", + "swift-bridge-macro", + "tokio", +] + +[[package]] +name = "swift-bridge-build" +version = "0.1.51" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "286f727dc922736a1ed74c06bebf43d08b8295a7ba38c77326c74e2b9dfd43df" +dependencies = [ + "proc-macro2", + "swift-bridge-ir", + "syn 1.0.109", + "tempfile", +] + +[[package]] +name = "swift-bridge-ir" +version = "0.1.51" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b4de97e9abde20abc1c01f6d4faa8072d723c73aba288264481a83a1e2787dc" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "swift-bridge-macro" +version = "0.1.51" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64fabad38a0fc643ceeafefed79e08408c30eeec325b629e426a15b13d055d0a" +dependencies = [ + "proc-macro2", + "quote", + "swift-bridge-ir", + "syn 1.0.109", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + +[[package]] +name = "tempfile" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998" +dependencies = [ + "cfg-if", + "fastrand", + "redox_syscall 0.3.5", + "rustix", + "windows-sys 0.45.0", +] + +[[package]] +name = "termcolor" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "thiserror" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "time" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a" +dependencies = [ + "libc", + "wasi 0.10.0+wasi-snapshot-preview1", + "winapi", +] + +[[package]] +name = "tokio" +version = "1.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0de47a4eecbe11f498978a9b29d792f0d2692d1dd003650c24c76510e3bc001" +dependencies = [ + "autocfg", + "bytes", + "libc", + "mio", + "num_cpus", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys 0.45.0", +] + +[[package]] +name = "tokio-io-timeout" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30b74022ada614a1b4834de765f9bb43877f910cc8ce4be40e89042c9223a8bf" +dependencies = [ + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tokio-macros" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61a573bdc87985e9d6ddeed1b3d864e8a302c847e40d647746df2f1de209d1ce" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.15", +] + +[[package]] +name = "tokio-rustls" +version = "0.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0d409377ff5b1e3ca6437aa86c1eb7d40c134bfec254e44c830defa92669db5" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-stream" +version = "0.1.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313" +dependencies = [ + "futures-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", + "tracing", +] + +[[package]] +name = "tonic" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f219fad3b929bef19b1f86fbc0358d35daed8f2cac972037ac0dc10bbb8d5fb" +dependencies = [ + "async-stream", + "async-trait", + "base64 0.13.1", + "bytes", + "futures-core", + "futures-util", + "http", + "http-body", + "percent-encoding", + "pin-project", + "prost", + "prost-derive", + "tokio-stream", + "tokio-util", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tonic" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38bd8e87955eb13c1986671838177d6792cdc52af9bffced0d2c8a9a7f741ab3" +dependencies = [ + "async-trait", + "axum", + "base64 0.21.0", + "bytes", + "futures-core", + "futures-util", + "h2", + "http", + "http-body", + "hyper", + "hyper-timeout", + "percent-encoding", + "pin-project", + "prost", + "tokio", + "tokio-stream", + "tower", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tonic-reflection" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67494bad4dda4c9bffae901dfe14e2b2c0f760adb4706dc10beeb81799f7f7b2" +dependencies = [ + "bytes", + "prost", + "prost-types", + "tokio", + "tokio-stream", + "tonic 0.8.3", +] + +[[package]] +name = "tower" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c" +dependencies = [ + "futures-core", + "futures-util", + "indexmap", + "pin-project", + "pin-project-lite", + "rand", + "slab", + "tokio", + "tokio-util", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower-layer" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0" + +[[package]] +name = "tower-service" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" + +[[package]] +name = "tracing" +version = "0.1.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" +dependencies = [ + "cfg-if", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "tracing-core" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a" +dependencies = [ + "once_cell", +] + +[[package]] +name = "try-lock" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" + +[[package]] +name = "typenum" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba" + +[[package]] +name = "unicode-ident" +version = "1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4" + +[[package]] +name = "unicode-width" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b" + +[[package]] +name = "universal-hash" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5" +dependencies = [ + "crypto-common", + "subtle", +] + +[[package]] +name = "untrusted" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" + +[[package]] +name = "version_check" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" + +[[package]] +name = "want" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0" +dependencies = [ + "log", + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.10.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "wasm-bindgen" +version = "0.2.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn 1.0.109", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.84" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d" + +[[package]] +name = "web-sys" +version = "0.3.61" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "which" +version = "4.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269" +dependencies = [ + "either", + "libc", + "once_cell", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" +dependencies = [ + "winapi", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +dependencies = [ + "windows-targets 0.48.0", +] + +[[package]] +name = "windows-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" +dependencies = [ + "windows-targets 0.42.2", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.0", +] + +[[package]] +name = "windows-targets" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" +dependencies = [ + "windows_aarch64_gnullvm 0.42.2", + "windows_aarch64_msvc 0.42.2", + "windows_i686_gnu 0.42.2", + "windows_i686_msvc 0.42.2", + "windows_x86_64_gnu 0.42.2", + "windows_x86_64_gnullvm 0.42.2", + "windows_x86_64_msvc 0.42.2", +] + +[[package]] +name = "windows-targets" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5" +dependencies = [ + "windows_aarch64_gnullvm 0.48.0", + "windows_aarch64_msvc 0.48.0", + "windows_i686_gnu 0.48.0", + "windows_i686_msvc 0.48.0", + "windows_x86_64_gnu 0.48.0", + "windows_x86_64_gnullvm 0.48.0", + "windows_x86_64_msvc 0.48.0", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3" + +[[package]] +name = "windows_i686_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241" + +[[package]] +name = "windows_i686_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.42.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a" + +[[package]] +name = "xmtp-keystore" +version = "0.1.0" +dependencies = [ + "base64 0.21.0", + "corecrypto", + "ecdsa", + "generic-array", + "hex", + "k256", + "protobuf", + "rand", + "rlp", + "sha3", +] + +[[package]] +name = "xmtp-networking" +version = "0.1.0" +dependencies = [ + "base64 0.21.0", + "pbjson", + "pbjson-types", + "prost", + "serde", + "serde_json", + "tokio", + "tokio-rustls", + "tonic 0.9.1", + "tonic-reflection", + "xmtp-proto", +] + +[[package]] +name = "xmtp-proto" +version = "0.1.0" +dependencies = [ + "pbjson", + "pbjson-types", + "prost", + "prost-types", + "serde", + "tonic 0.9.1", +] + +[[package]] +name = "xmtp_rust_swift" +version = "0.1.0" +dependencies = [ + "swift-bridge", + "swift-bridge-build", + "tokio", + "xmtp-networking", +] + +[[package]] +name = "zeroize" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 000000000..8c25aaf1e --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,9 @@ +[workspace] + +members = [ + "bindings/xmtp_rust_swift", + "crates/xmtp-proto", + "crates/xmtp-keystore", + "crates/corecrypto", + "crates/xmtp-networking", +] diff --git a/bindings/xmtp_rust_swift/.gitignore b/bindings/xmtp_rust_swift/.gitignore index 55bf7419a..bc0e7469f 100644 --- a/bindings/xmtp_rust_swift/.gitignore +++ b/bindings/xmtp_rust_swift/.gitignore @@ -13,3 +13,4 @@ bundle.zip /target /Cargo.lock .build +./Generated \ No newline at end of file diff --git a/bindings/xmtp_rust_swift/src/lib.rs b/bindings/xmtp_rust_swift/src/lib.rs index 9f934ca6e..e831d4db7 100644 --- a/bindings/xmtp_rust_swift/src/lib.rs +++ b/bindings/xmtp_rust_swift/src/lib.rs @@ -57,7 +57,7 @@ mod tests { fn test_query() { let runtime = tokio::runtime::Runtime::new().unwrap(); let result = runtime.block_on(super::query( - "http://localhost:15555".to_string(), + "http://localhost:5556".to_string(), "test".to_string(), "".to_string(), )); diff --git a/crates/Cargo.lock b/crates/Cargo.lock index 5b171cb5a..4fb522d27 100644 --- a/crates/Cargo.lock +++ b/crates/Cargo.lock @@ -907,6 +907,43 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5" +[[package]] +name = "pbjson" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "048f9ac93c1eab514f9470c4bc8d97ca2a0a236b84f45cc19d69a59fc11467f6" +dependencies = [ + "base64 0.13.1", + "serde", +] + +[[package]] +name = "pbjson-build" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bdbb7b706f2afc610f3853550cdbbf6372fd324824a087806bd4480ea4996e24" +dependencies = [ + "heck", + "itertools", + "prost", + "prost-types", +] + +[[package]] +name = "pbjson-types" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a88c8d87f99a4ac14325e7a4c24af190fca261956e3b82dd7ed67e77e6c7043" +dependencies = [ + "bytes", + "chrono", + "pbjson", + "pbjson-build", + "prost", + "prost-build", + "serde", +] + [[package]] name = "percent-encoding" version = "2.2.0" @@ -1996,6 +2033,8 @@ name = "xmtp-networking" version = "0.1.0" dependencies = [ "base64 0.21.0", + "pbjson", + "pbjson-types", "prost", "serde", "serde_json", diff --git a/crates/Cargo.toml b/crates/Cargo.toml deleted file mode 100644 index 12689493b..000000000 --- a/crates/Cargo.toml +++ /dev/null @@ -1,7 +0,0 @@ -[workspace] - -members = [ - "xmtp-keystore", - "corecrypto", - "xmtp-networking", -] diff --git a/crates/xmtp-networking/Cargo.toml b/crates/xmtp-networking/Cargo.toml index dedfdccc7..62030abe7 100644 --- a/crates/xmtp-networking/Cargo.toml +++ b/crates/xmtp-networking/Cargo.toml @@ -7,7 +7,8 @@ edition = "2021" [dependencies] tonic = "^0.9" -prost = "^0.11" +xmtp-proto = { path = "../xmtp-proto", features = ["proto_full"] } +prost = { version = "^0.11", features = ["prost-derive"] } tokio = { version = "1.24", features = ["macros", "rt-multi-thread"] } #tokio-stream = { version = "0.1", features = ["net"] } #futures = "0.3" @@ -17,6 +18,5 @@ tokio-rustls = "0.24.0" serde = { version = "1.0.160", features = ["derive"] } serde_json = "1.0" base64 = "0.21.0" - -[build-dependencies] -tonic-build = "^0.9" +pbjson = "0.5.1" +pbjson-types = "0.5.1" \ No newline at end of file diff --git a/crates/xmtp-networking/build.rs b/crates/xmtp-networking/build.rs deleted file mode 100644 index f4df76953..000000000 --- a/crates/xmtp-networking/build.rs +++ /dev/null @@ -1,46 +0,0 @@ -use std::env; -use std::path::PathBuf; - -fn main() -> Result<(), Box> { - let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap()); - - // NOTE: requires googleapis as a submodule, per: https://docs.rs/crate/tonic-build/latest - // Go to proto folder and run: - // - // git submodule add https://github.com/googleapis/googleapis - // git submodule update --remote - - tonic_build::configure() - .protoc_arg("--experimental_allow_proto3_optional") // for older systems - .build_client(true) - .type_attribute(".", "#[derive(serde::Deserialize, serde::Serialize)]") - .file_descriptor_set_path(out_dir.join("store_descriptor.bin")) - .field_attribute( - "xmtp.message_api.v1.Envelope.message", - "#[serde(serialize_with = \"crate::serialize_utils::as_base64\")]", - ) - .field_attribute( - "xmtp.message_api.v1.IndexCursor.digest", - "#[serde(serialize_with = \"crate::serialize_utils::as_base64\")]", - ) - .out_dir("./src") - .compile( - &[ - "proto/message_contents/composite.proto", - "proto/message_contents/signature.proto", - "proto/message_contents/ciphertext.proto", - "proto/message_contents/public_key.proto", - "proto/message_contents/contact.proto", - "proto/message_contents/invitation.proto", - "proto/message_contents/private_key.proto", - "proto/message_contents/message.proto", - "proto/message_contents/content.proto", - "proto/message_api/v1/authn.proto", - "proto/message_api/v1/message_api.proto", - "proto/keystore_api/v1/keystore.proto", - ], - &["proto", "proto/googleapis"], - )?; - - Ok(()) -} diff --git a/crates/xmtp-networking/proto/googleapis b/crates/xmtp-networking/proto/googleapis deleted file mode 160000 index 6e21f1abd..000000000 --- a/crates/xmtp-networking/proto/googleapis +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 6e21f1abdb1f23729660c9891f5efa4dc956c77d diff --git a/crates/xmtp-networking/proto/keystore_api/v1/keystore.proto b/crates/xmtp-networking/proto/keystore_api/v1/keystore.proto deleted file mode 100644 index 969b95c62..000000000 --- a/crates/xmtp-networking/proto/keystore_api/v1/keystore.proto +++ /dev/null @@ -1,186 +0,0 @@ -// Message content encoding structures -syntax = "proto3"; - -package xmtp.keystore_api.v1; - -import "message_contents/ciphertext.proto"; -import "message_contents/invitation.proto"; -import "message_contents/public_key.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/keystore_api/v1"; -option java_package = "org.xmtp.proto.keystore.api.v1"; - -// Application-specific error codes for the Keystore API. -enum ErrorCode { - ERROR_CODE_UNSPECIFIED = 0; - ERROR_CODE_INVALID_INPUT = 1; - ERROR_CODE_NO_MATCHING_PREKEY = 2; -} - -// Wrapper class for errors from the Keystore API -message KeystoreError { - string message = 1; - ErrorCode code = 2; -} - -// A light pointer for a conversation that contains no decryption keys -message ConversationReference { - string topic = 1; - string peer_address = 2; - uint64 created_ns = 3; - xmtp.message_contents.InvitationV1.Context context = 4; -} - -// Decrypt a batch of messages using X3DH key agreement -message DecryptV1Request { - // A single decryption request - message Request { - xmtp.message_contents.Ciphertext payload = 1; - xmtp.message_contents.PublicKeyBundle peer_keys = 2; - bytes header_bytes = 3; - bool is_sender = 4; - } - - repeated Request requests = 1; -} - -// Response type for both V1 and V2 decryption requests -message DecryptResponse { - // A single decryption response - message Response { - // Wrapper object for success response - message Success { - bytes decrypted = 1; - } - - oneof response { - Success result = 1; - KeystoreError error = 2; - } - } - - repeated Response responses = 1; -} - -// Decrypt a batch of messages using the appropriate topic keys -message DecryptV2Request { - // A single decryption request - message Request { - xmtp.message_contents.Ciphertext payload = 1; - bytes header_bytes = 2; - string content_topic = 3; - } - - repeated Request requests = 1; -} - -// Encrypt a batch of messages using X3DH key agreement -message EncryptV1Request { - // A single encryption request - message Request { - xmtp.message_contents.PublicKeyBundle recipient = 1; - bytes payload = 2; - bytes header_bytes = 3; - } - - repeated Request requests = 1; -} - -// Response type for both V1 and V2 encryption requests -message EncryptResponse { - // A single encryption response - message Response { - // Wrapper object for success response - message Success { - xmtp.message_contents.Ciphertext encrypted = 1; - } - - oneof response { - Success result = 1; - KeystoreError error = 2; - } - } - - repeated Response responses = 1; -} - -// Encrypt a batch of messages using the appropriate topic keys -message EncryptV2Request { - // A single encryption request - message Request { - bytes payload = 1; - bytes header_bytes = 2; - string content_topic = 3; - } - - repeated Request requests = 1; -} - -// Request to create an invite payload, and store the topic keys in the Keystore -message CreateInviteRequest { - xmtp.message_contents.InvitationV1.Context context = 1; - xmtp.message_contents.SignedPublicKeyBundle recipient = 2; - uint64 created_ns = 3; -} - -// Response to a CreateInviteRequest -message CreateInviteResponse { - ConversationReference conversation = 1; - bytes payload = 2; -} - -// Request to save a batch of invite messages to the Keystore -message SaveInvitesRequest { - // Mirrors xmtp.envelope schema - message Request { - string content_topic = 1; - uint64 timestamp_ns = 2; - bytes payload = 3; - } - - repeated Request requests = 1; -} - -// Response to a SaveInvitesRequest -message SaveInvitesResponse { - // A single response - message Response { - // Wrapper object for success response - message Success { - ConversationReference conversation = 1; - } - - oneof response { - Success result = 1; - KeystoreError error = 2; - } - } - - repeated Response responses = 1; -} - -// CreateAuthTokenRequest is used to create an auth token for the XMTP API -message CreateAuthTokenRequest { - optional uint64 timestamp_ns = 1; -} - -// SignDigestRequest is used to sign a digest with either the identity key -// or a prekey -message SignDigestRequest { - bytes digest = 1; - oneof signer { - bool identity_key = 2; - uint32 prekey_index = 3; - } -} - -// A mapping of topics to their decrypted invitations -message TopicMap { - // TopicData wraps the invitation and the timestamp it was created - message TopicData { - uint64 created_ns = 1; - string peer_address = 2; - xmtp.message_contents.InvitationV1 invitation = 3; - } - map topics = 1; -} \ No newline at end of file diff --git a/crates/xmtp-networking/proto/message_api/v1/authn.proto b/crates/xmtp-networking/proto/message_api/v1/authn.proto deleted file mode 100644 index 38a37008b..000000000 --- a/crates/xmtp-networking/proto/message_api/v1/authn.proto +++ /dev/null @@ -1,32 +0,0 @@ -// Client authentication protocol -syntax = "proto3"; -package xmtp.message_api.v1; - -import "message_contents/public_key.proto"; -import "message_contents/signature.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_api/v1"; -option java_package = "org.xmtp.proto.message.api.v1"; - -// Token is used by clients to prove to the nodes -// that they are serving a specific wallet. -message Token { - // identity key signed by a wallet - xmtp.message_contents.PublicKey identity_key = 1; - // encoded bytes of AuthData - bytes auth_data_bytes = 2; - // identity key signature of AuthData bytes - xmtp.message_contents.Signature auth_data_signature = 3; -} - -// AuthData carries token parameters that are authenticated -// by the identity key signature. -// It is embedded in the Token structure as bytes -// so that the bytes don't need to be reconstructed -// to verify the token signature. -message AuthData { - // address of the wallet - string wallet_addr = 1; - // time when the token was generated/signed - uint64 created_ns = 2; -} diff --git a/crates/xmtp-networking/proto/message_api/v1/message_api.proto b/crates/xmtp-networking/proto/message_api/v1/message_api.proto deleted file mode 100644 index 2d7416213..000000000 --- a/crates/xmtp-networking/proto/message_api/v1/message_api.proto +++ /dev/null @@ -1,137 +0,0 @@ -// Message API -syntax = "proto3"; -package xmtp.message_api.v1; - -import "google/api/annotations.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_api/v1"; -option java_package = "org.xmtp.proto.message.api.v1"; - -// RPC -service MessageApi { - // Publish messages to the network - rpc Publish (PublishRequest) returns (PublishResponse) { - option (google.api.http) = { - post: "/message/v1/publish" - body: "*" - }; - } - // Subscribe to a stream of new envelopes matching a predicate - rpc Subscribe (SubscribeRequest) returns (stream Envelope) { - option (google.api.http) = { - post: "/message/v1/subscribe" - body: "*" - }; - } - // Subscribe to a stream of all messages - rpc SubscribeAll (SubscribeAllRequest) returns (stream Envelope) { - option (google.api.http) = { - post: "/message/v1/subscribe-all" - body: "*" - }; - } - // Query the store for messages - rpc Query (QueryRequest) returns (QueryResponse) { - option (google.api.http) = { - post: "/message/v1/query" - body: "*" - }; - } - // BatchQuery containing a set of queries to be processed - rpc BatchQuery (BatchQueryRequest) returns (BatchQueryResponse) { - option (google.api.http) = { - post: "/message/v1/batch-query" - body: "*" - }; - } -} - -// Sort direction -enum SortDirection { - SORT_DIRECTION_UNSPECIFIED = 0; - SORT_DIRECTION_ASCENDING = 1; - SORT_DIRECTION_DESCENDING = 2; -} - -// This is based off of the go-waku Index type, but with the -// receiverTime and pubsubTopic removed for simplicity. -// Both removed fields are optional -message IndexCursor { - bytes digest = 1; - uint64 sender_time_ns = 2; -} - -// Wrapper for potentially multiple types of cursor -message Cursor { - // Making the cursor a one-of type, as I would like to change the way we - // handle pagination to use a precomputed sort field. - // This way we can handle both methods - oneof cursor { - IndexCursor index = 1; - } -} - -// This is based off of the go-waku PagingInfo struct, but with the direction -// changed to our SortDirection enum format -message PagingInfo { - // Note: this is a uint32, while go-waku's pageSize is a uint64 - uint32 limit = 1; - Cursor cursor = 2; - SortDirection direction = 3; -} - -// Envelope encapsulates a message while in transit. -message Envelope { - // The topic the message belongs to, - // If the message includes the topic as well - // it MUST be the same as the topic in the envelope. - string content_topic = 1; - // Message creation timestamp - // If the message includes the timestamp as well - // it MUST be equivalent to the timestamp in the envelope. - uint64 timestamp_ns = 2; - bytes message = 3; -} - -// Publish -message PublishRequest { - repeated Envelope envelopes = 1; -} - -// Empty message as a response for Publish -message PublishResponse{ -} - -// Subscribe -message SubscribeRequest { - repeated string content_topics = 1; -} - -// SubscribeAll -message SubscribeAllRequest { -} - - -// Query -message QueryRequest { - repeated string content_topics = 1; - uint64 start_time_ns = 2; - uint64 end_time_ns = 3; - PagingInfo paging_info = 4; -} - -// The response, containing envelopes, for a query -message QueryResponse{ - repeated Envelope envelopes = 1; - PagingInfo paging_info = 2; -} - -// BatchQuery -message BatchQueryRequest { - repeated QueryRequest requests = 1; -} - -// Response containing a list of QueryResponse messages -message BatchQueryResponse { - repeated QueryResponse responses = 1; -} diff --git a/crates/xmtp-networking/proto/message_contents/ciphertext.proto b/crates/xmtp-networking/proto/message_contents/ciphertext.proto deleted file mode 100644 index fc63a32a5..000000000 --- a/crates/xmtp-networking/proto/message_contents/ciphertext.proto +++ /dev/null @@ -1,45 +0,0 @@ -// Ciphertext is a generic structure for encrypted payload. -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/signature.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// Ciphertext represents encrypted payload. -// It is definited as a union to support cryptographic algorithm agility. -// The payload is accompanied by the cryptographic parameters -// required by the chosen encryption scheme. -message Ciphertext { - oneof union { - Aes256gcmHkdfsha256 aes256_gcm_hkdf_sha256 = 1; - } - - // Supported Encryption Schemes - - // Encryption: AES256-GCM - // Key derivation function: HKDF-SHA256 - message Aes256gcmHkdfsha256 { - bytes hkdf_salt = 1; // 32 bytes - bytes gcm_nonce = 2; // 12 bytes - bytes payload = 3; // encrypted payload - } -} - -// SignedEciesCiphertext represents an ECIES encrypted payload and a signature -message SignedEciesCiphertext { - // Ecies is ciphertext encrypted using ECIES with a MAC - message Ecies { - bytes ephemeral_public_key = 1; // 65 bytes - bytes iv = 2; // 16 bytes - bytes mac = 3; // 32 bytes - bytes ciphertext = 4; // encrypted payload with block size of 16 - } - - // serialized Ecies message - bytes ecies_bytes = 1; - // signature of sha256(ecies_bytes) signed with the IdentityKey - xmtp.message_contents.Signature signature = 2; -} \ No newline at end of file diff --git a/crates/xmtp-networking/proto/message_contents/composite.proto b/crates/xmtp-networking/proto/message_contents/composite.proto deleted file mode 100644 index 464f3a11c..000000000 --- a/crates/xmtp-networking/proto/message_contents/composite.proto +++ /dev/null @@ -1,22 +0,0 @@ -// Composite ContentType -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/content.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// Composite is used to implement xmtp.org/composite content type -message Composite { - // Part represents one section of a composite message - message Part { - oneof element { - EncodedContent part = 1; - Composite composite = 2; - } - } - - repeated Part parts = 1; -} diff --git a/crates/xmtp-networking/proto/message_contents/contact.proto b/crates/xmtp-networking/proto/message_contents/contact.proto deleted file mode 100644 index 3f31a02a4..000000000 --- a/crates/xmtp-networking/proto/message_contents/contact.proto +++ /dev/null @@ -1,32 +0,0 @@ -// Contact Bundles are used to advertise user's public keys on the network. -// They are published in well known topics so that other participants -// can find them when they wish to communicate with the user. -// The public keys are used to sign messages and to derive encryption keys -// for some meta-messages, e.g. invitations. -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/public_key.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// LEGACY: User key bundle V1 using PublicKeys. -// The PublicKeys MUST be signed. -message ContactBundleV1 { - PublicKeyBundle key_bundle = 1; -} - -// User key bundle V2 using SignedPublicKeys. -message ContactBundleV2 { - SignedPublicKeyBundle key_bundle = 1; -} - -// Versioned ContactBundle -message ContactBundle { - oneof version { - ContactBundleV1 v1 = 1; - ContactBundleV2 v2 = 2; - } -} diff --git a/crates/xmtp-networking/proto/message_contents/content.proto b/crates/xmtp-networking/proto/message_contents/content.proto deleted file mode 100644 index 14c1de643..000000000 --- a/crates/xmtp-networking/proto/message_contents/content.proto +++ /dev/null @@ -1,55 +0,0 @@ -// Message content encoding structures -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/public_key.proto"; -import "message_contents/signature.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// ContentTypeId is used to identify the type of content stored in a Message. -message ContentTypeId { - string authority_id = 1; // authority governing this content type - string type_id = 2; // type identifier - uint32 version_major = 3; // major version of the type - uint32 version_minor = 4; // minor version of the type -} - -// Recognized compression algorithms -// protolint:disable ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH -enum Compression { - COMPRESSION_DEFLATE = 0; - COMPRESSION_GZIP = 1; -} -// protolint:enable ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH - -// EncodedContent bundles the content with metadata identifying its type -// and parameters required for correct decoding and presentation of the content. -message EncodedContent { - // content type identifier used to match the payload with - // the correct decoding machinery - ContentTypeId type = 1; - // optional encoding parameters required to correctly decode the content - map parameters = 2; - // optional fallback description of the content that can be used in case - // the client cannot decode or render the content - optional string fallback = 3; - // optional compression; the value indicates algorithm used to - // compress the encoded content bytes - optional Compression compression = 5; - // encoded content itself - bytes content = 4; -} - -// SignedContent attaches a signature to EncodedContent. -message SignedContent { - // MUST contain EncodedContent - bytes payload = 1; - SignedPublicKeyBundle sender = 2; - // MUST be a signature of a concatenation of - // the message header bytes and the payload bytes, - // signed by the sender's pre-key. - Signature signature = 3; -} diff --git a/crates/xmtp-networking/proto/message_contents/invitation.proto b/crates/xmtp-networking/proto/message_contents/invitation.proto deleted file mode 100644 index 92c7f84f8..000000000 --- a/crates/xmtp-networking/proto/message_contents/invitation.proto +++ /dev/null @@ -1,72 +0,0 @@ -// Invitation is used by an initiator to invite participants -// into a new conversation. Invitation carries the chosen topic name -// and encryption scheme and key material to be used for message encryption. -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/ciphertext.proto"; -import "message_contents/public_key.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// Unsealed invitation V1 -message InvitationV1 { - // Supported encryption schemes - // AES256-GCM-HKDF-SHA256 - message Aes256gcmHkdfsha256 { - bytes key_material = 1; // randomly generated key material (32 bytes) - } - - // The context type - message Context { - // Expected to be a URI (ie xmtp.org/convo1) - string conversation_id = 1; - // Key value map of additional metadata that would be exposed to - // application developers and could be used for filtering - map metadata = 2; - } - // topic name chosen for this conversation. - // It MUST be randomly generated bytes (length >= 32), - // then base64 encoded without padding - string topic = 1; - - // A context object defining metadata - Context context = 2; - - // message encryption scheme and keys for this conversation. - oneof encryption { - // Specify the encryption method to process the key material properly. - Aes256gcmHkdfsha256 aes256_gcm_hkdf_sha256 = 3; - } -} - - -// Sealed Invitation V1 Header -// Header carries information that is unencrypted, thus readable by the network -// it is however authenticated as associated data with the AEAD scheme used -// to encrypt the invitation body, thus providing tamper evidence. -message SealedInvitationHeaderV1 { - SignedPublicKeyBundle sender = 1; - SignedPublicKeyBundle recipient = 2; - uint64 created_ns = 3; -} - -// Sealed Invitation V1 -// Invitation encrypted with key material derived from the sender's and -// recipient's public key bundles using simplified X3DH where -// the sender's ephemeral key is replaced with sender's pre-key. -message SealedInvitationV1 { - // encoded SealedInvitationHeaderV1 used as associated data for Ciphertext - bytes header_bytes = 1; - // Ciphertext.payload MUST contain encrypted InvitationV1. - Ciphertext ciphertext = 2; -} - -// Versioned Sealed Invitation -message SealedInvitation { - oneof version { - SealedInvitationV1 v1 = 1; - }; -} diff --git a/crates/xmtp-networking/proto/message_contents/message.proto b/crates/xmtp-networking/proto/message_contents/message.proto deleted file mode 100644 index 6081e75dc..000000000 --- a/crates/xmtp-networking/proto/message_contents/message.proto +++ /dev/null @@ -1,71 +0,0 @@ -// Messages used for transport and storage of user conversations. -syntax = "proto3"; - -package xmtp.message_contents; - -import "keystore_api/v1/keystore.proto"; -import "message_contents/ciphertext.proto"; -import "message_contents/public_key.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// Message V1 - -// Message header is encoded separately as the bytes are also used -// as associated data for authenticated encryption -message MessageHeaderV1 { - PublicKeyBundle sender = 1; - PublicKeyBundle recipient = 2; - uint64 timestamp = 3; -} - -// Message is the top level protocol element -message MessageV1 { - bytes header_bytes = 1; // encapsulates encoded MessageHeaderV1 - // Ciphertext.payload MUST contain encrypted EncodedContent - Ciphertext ciphertext = 2; -} - -// Message V2 - -// Message header carries information that is not encrypted, and is therefore -// observable by the network. It is however authenticated as associated data -// of the AEAD encryption used to protect the message, -// thus providing tamper evidence. -message MessageHeaderV2 { - // sender specified message creation time - uint64 created_ns = 1; - // the topic the message belongs to - string topic = 2; -} - -// Message combines the encoded header with the encrypted payload. -message MessageV2 { - bytes header_bytes = 1; // encapsulates encoded MessageHeaderV2 - // Ciphertext.payload MUST contain encrypted SignedContent - Ciphertext ciphertext = 2; -} - - -// Versioned Message -message Message { - oneof version { - MessageV1 v1 = 1; - MessageV2 v2 = 2; - } -} - -// DecodedMessage represents the decrypted message contents. -// DecodedMessage instances are not stored on the network, but -// may be serialized and stored by clients -message DecodedMessage { - string id = 1; - string message_version = 2; - string sender_address = 3; - optional string recipient_address = 4; - uint64 sent_ns = 5; - string content_topic = 6; - xmtp.keystore_api.v1.ConversationReference conversation = 7; - bytes content_bytes = 8; // encapsulates EncodedContent -} \ No newline at end of file diff --git a/crates/xmtp-networking/proto/message_contents/private_key.proto b/crates/xmtp-networking/proto/message_contents/private_key.proto deleted file mode 100644 index 15a794db6..000000000 --- a/crates/xmtp-networking/proto/message_contents/private_key.proto +++ /dev/null @@ -1,95 +0,0 @@ -// Private Key Storage -// -// Following definitions are not used in the protocol, instead -// they provide a way for encoding private keys for storage. -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/ciphertext.proto"; -import "message_contents/public_key.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// PrivateKey generalized to support different key types -message SignedPrivateKey { - // time the key was created - uint64 created_ns = 1; - // private key - oneof union { - Secp256k1 secp256k1 = 2; - } - // public key for this private key - SignedPublicKey public_key = 3; - - // Supported key types - - // EC: SECP256k1 - message Secp256k1 { - bytes bytes = 1; // D big-endian, 32 bytes - } -} - -// PrivateKeyBundle wraps the identityKey and the preKeys, -// enforces usage of signed keys. -message PrivateKeyBundleV2 { - SignedPrivateKey identity_key = 1; - // all the known pre-keys, newer keys first, - repeated SignedPrivateKey pre_keys = 2; -} - -// LEGACY: PrivateKey generalized to support different key types -message PrivateKey { - // time the key was created - uint64 timestamp = 1; - // private key - oneof union { - Secp256k1 secp256k1 = 2; - } - // public key for this private key - PublicKey public_key = 3; - - // Supported key types - - // EC: SECP256k1 - message Secp256k1 { - bytes bytes = 1; // D big-endian, 32 bytes - } -} - -// LEGACY: PrivateKeyBundleV1 wraps the identityKey and the preKeys -message PrivateKeyBundleV1 { - PrivateKey identity_key = 1; - // all the known pre-keys, newer keys first, - repeated PrivateKey pre_keys = 2; -} - - - -// Versioned PrivateKeyBundle -message PrivateKeyBundle { - oneof version { - PrivateKeyBundleV1 v1 = 1; - PrivateKeyBundleV2 v2 = 2; - } -} - -// PrivateKeyBundle encrypted with key material generated by -// signing a randomly generated "pre-key" with the user's wallet, -// i.e. EIP-191 signature of a "storage signature" message with -// the pre-key embedded in it. -// (see xmtp-js::PrivateKeyBundle.toEncryptedBytes for details) -message EncryptedPrivateKeyBundleV1 { - // randomly generated pre-key - bytes wallet_pre_key = 1; // 32 bytes - // MUST contain encrypted PrivateKeyBundle - Ciphertext ciphertext = 2; -} - -// Versioned encrypted PrivateKeyBundle -message EncryptedPrivateKeyBundle { - oneof version { - EncryptedPrivateKeyBundleV1 v1 = 1; - } -} diff --git a/crates/xmtp-networking/proto/message_contents/public_key.proto b/crates/xmtp-networking/proto/message_contents/public_key.proto deleted file mode 100644 index db6c18ded..000000000 --- a/crates/xmtp-networking/proto/message_contents/public_key.proto +++ /dev/null @@ -1,67 +0,0 @@ -// Structure for representing public keys of different types, -// including signatures used to authenticate the keys. -syntax = "proto3"; - -package xmtp.message_contents; - -import "message_contents/signature.proto"; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// UnsignedPublicKey represents a generalized public key, -// defined as a union to support cryptographic algorithm agility. -message UnsignedPublicKey { - uint64 created_ns = 1; - oneof union { - Secp256k1Uncompressed secp256k1_uncompressed = 3; - } - - // Supported key types - - // EC: SECP256k1 - message Secp256k1Uncompressed { - // uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes - bytes bytes = 1; - } -} - -// SignedPublicKey -message SignedPublicKey { - bytes key_bytes = 1; // embeds an UnsignedPublicKey - Signature signature = 2; // signs key_bytes -} - -// PublicKeyBundle packages the cryptographic keys associated with a wallet. -message SignedPublicKeyBundle { - // Identity key MUST be signed by the wallet. - SignedPublicKey identity_key = 1; - // Pre-key MUST be signed by the identity key. - SignedPublicKey pre_key = 2; -} - -// LEGACY - -// PublicKey represents a generalized public key, -// defined as a union to support cryptographic algorithm agility. -message PublicKey { - // The key bytes - message Secp256k1Uncompressed { - // uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes - bytes bytes = 1; - } - uint64 timestamp = 1; - optional Signature signature = 2; - oneof union { - Secp256k1Uncompressed secp256k1_uncompressed = 3; - } -} - -// PublicKeyBundle packages the cryptographic keys associated with a wallet, -// both senders and recipients are identified by their key bundles. -message PublicKeyBundle { - // Identity key MUST be signed by the wallet. - PublicKey identity_key = 1; - // Pre-key MUST be signed by the identity key. - PublicKey pre_key = 2; -} diff --git a/crates/xmtp-networking/proto/message_contents/signature.proto b/crates/xmtp-networking/proto/message_contents/signature.proto deleted file mode 100644 index d470c29fe..000000000 --- a/crates/xmtp-networking/proto/message_contents/signature.proto +++ /dev/null @@ -1,29 +0,0 @@ -// Signature is a generic structure for public key signatures. -syntax = "proto3"; - -package xmtp.message_contents; - -option go_package = "github.com/xmtp/proto/v3/go/message_contents"; -option java_package = "org.xmtp.proto.message.contents"; - -// Signature represents a generalized public key signature, -// defined as a union to support cryptographic algorithm agility. -message Signature { - // ECDSA signature bytes and the recovery bit - message ECDSACompact { - bytes bytes = 1; // compact representation [ R || S ], 64 bytes - uint32 recovery = 2; // recovery bit - } - // ECDSA signature bytes and the recovery bit - // produced by xmtp-js::PublicKey.signWithWallet function, i.e. - // EIP-191 signature of a "Create Identity" message with the key embedded. - // Used to sign identity keys. - message WalletECDSACompact { - bytes bytes = 1; // compact representation [ R || S ], 64 bytes - uint32 recovery = 2; // recovery bit - } - oneof union { - ECDSACompact ecdsa_compact = 1; - WalletECDSACompact wallet_ecdsa_compact = 2; - } -} diff --git a/crates/xmtp-networking/src/google.api.rs b/crates/xmtp-networking/src/google.api.rs deleted file mode 100644 index dda77a814..000000000 --- a/crates/xmtp-networking/src/google.api.rs +++ /dev/null @@ -1,375 +0,0 @@ -/// Defines the HTTP configuration for an API service. It contains a list of -/// \[HttpRule][google.api.HttpRule\], each specifying the mapping of an RPC method -/// to one or more HTTP REST API methods. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Http { - /// A list of HTTP configuration rules that apply to individual API methods. - /// - /// **NOTE:** All service configuration rules follow "last one wins" order. - #[prost(message, repeated, tag = "1")] - pub rules: ::prost::alloc::vec::Vec, - /// When set to true, URL path parameters will be fully URI-decoded except in - /// cases of single segment matches in reserved expansion, where "%2F" will be - /// left encoded. - /// - /// The default behavior is to not decode RFC 6570 reserved characters in multi - /// segment matches. - #[prost(bool, tag = "2")] - pub fully_decode_reserved_expansion: bool, -} -/// # gRPC Transcoding -/// -/// gRPC Transcoding is a feature for mapping between a gRPC method and one or -/// more HTTP REST endpoints. It allows developers to build a single API service -/// that supports both gRPC APIs and REST APIs. Many systems, including [Google -/// APIs](), -/// [Cloud Endpoints](), [gRPC -/// Gateway](), -/// and \[Envoy\]() proxy support this feature -/// and use it for large scale production services. -/// -/// `HttpRule` defines the schema of the gRPC/REST mapping. The mapping specifies -/// how different portions of the gRPC request message are mapped to the URL -/// path, URL query parameters, and HTTP request body. It also controls how the -/// gRPC response message is mapped to the HTTP response body. `HttpRule` is -/// typically specified as an `google.api.http` annotation on the gRPC method. -/// -/// Each mapping specifies a URL path template and an HTTP method. The path -/// template may refer to one or more fields in the gRPC request message, as long -/// as each field is a non-repeated field with a primitive (non-message) type. -/// The path template controls how fields of the request message are mapped to -/// the URL path. -/// -/// Example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get: "/v1/{name=messages/*}" -/// }; -/// } -/// } -/// message GetMessageRequest { -/// string name = 1; // Mapped to URL path. -/// } -/// message Message { -/// string text = 1; // The resource content. -/// } -/// -/// This enables an HTTP REST to gRPC mapping as below: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(name: "messages/123456")` -/// -/// Any fields in the request message which are not bound by the path template -/// automatically become HTTP query parameters if there is no HTTP request body. -/// For example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get:"/v1/messages/{message_id}" -/// }; -/// } -/// } -/// message GetMessageRequest { -/// message SubMessage { -/// string subfield = 1; -/// } -/// string message_id = 1; // Mapped to URL path. -/// int64 revision = 2; // Mapped to URL query parameter `revision`. -/// SubMessage sub = 3; // Mapped to URL query parameter `sub.subfield`. -/// } -/// -/// This enables a HTTP JSON to RPC mapping as below: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | -/// `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: -/// "foo"))` -/// -/// Note that fields which are mapped to URL query parameters must have a -/// primitive type or a repeated primitive type or a non-repeated message type. -/// In the case of a repeated type, the parameter can be repeated in the URL -/// as `...?param=A¶m=B`. In the case of a message type, each field of the -/// message is mapped to a separate parameter, such as -/// `...?foo.a=A&foo.b=B&foo.c=C`. -/// -/// For HTTP methods that allow a request body, the `body` field -/// specifies the mapping. Consider a REST update method on the -/// message resource collection: -/// -/// service Messaging { -/// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// patch: "/v1/messages/{message_id}" -/// body: "message" -/// }; -/// } -/// } -/// message UpdateMessageRequest { -/// string message_id = 1; // mapped to the URL -/// Message message = 2; // mapped to the body -/// } -/// -/// The following HTTP JSON to RPC mapping is enabled, where the -/// representation of the JSON in the request body is determined by -/// protos JSON encoding: -/// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" message { text: "Hi!" })` -/// -/// The special name `*` can be used in the body mapping to define that -/// every field not bound by the path template should be mapped to the -/// request body. This enables the following alternative definition of -/// the update method: -/// -/// service Messaging { -/// rpc UpdateMessage(Message) returns (Message) { -/// option (google.api.http) = { -/// patch: "/v1/messages/{message_id}" -/// body: "*" -/// }; -/// } -/// } -/// message Message { -/// string message_id = 1; -/// string text = 2; -/// } -/// -/// -/// The following HTTP JSON to RPC mapping is enabled: -/// -/// HTTP | gRPC -/// -----|----- -/// `PATCH /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: -/// "123456" text: "Hi!")` -/// -/// Note that when using `*` in the body mapping, it is not possible to -/// have HTTP parameters, as all fields not bound by the path end in -/// the body. This makes this option more rarely used in practice when -/// defining REST APIs. The common usage of `*` is in custom methods -/// which don't use the URL at all for transferring data. -/// -/// It is possible to define multiple HTTP methods for one RPC by using -/// the `additional_bindings` option. Example: -/// -/// service Messaging { -/// rpc GetMessage(GetMessageRequest) returns (Message) { -/// option (google.api.http) = { -/// get: "/v1/messages/{message_id}" -/// additional_bindings { -/// get: "/v1/users/{user_id}/messages/{message_id}" -/// } -/// }; -/// } -/// } -/// message GetMessageRequest { -/// string message_id = 1; -/// string user_id = 2; -/// } -/// -/// This enables the following two alternative HTTP JSON to RPC mappings: -/// -/// HTTP | gRPC -/// -----|----- -/// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")` -/// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: -/// "123456")` -/// -/// ## Rules for HTTP mapping -/// -/// 1. Leaf request fields (recursive expansion nested messages in the request -/// message) are classified into three categories: -/// - Fields referred by the path template. They are passed via the URL path. -/// - Fields referred by the \[HttpRule.body][google.api.HttpRule.body\]. They -/// are passed via the HTTP -/// request body. -/// - All other fields are passed via the URL query parameters, and the -/// parameter name is the field path in the request message. A repeated -/// field can be represented as multiple query parameters under the same -/// name. -/// 2. If \[HttpRule.body][google.api.HttpRule.body\] is "*", there is no URL -/// query parameter, all fields -/// are passed via URL path and HTTP request body. -/// 3. If \[HttpRule.body][google.api.HttpRule.body\] is omitted, there is no HTTP -/// request body, all -/// fields are passed via URL path and URL query parameters. -/// -/// ### Path template syntax -/// -/// Template = "/" Segments [ Verb ] ; -/// Segments = Segment { "/" Segment } ; -/// Segment = "*" | "**" | LITERAL | Variable ; -/// Variable = "{" FieldPath [ "=" Segments ] "}" ; -/// FieldPath = IDENT { "." IDENT } ; -/// Verb = ":" LITERAL ; -/// -/// The syntax `*` matches a single URL path segment. The syntax `**` matches -/// zero or more URL path segments, which must be the last part of the URL path -/// except the `Verb`. -/// -/// The syntax `Variable` matches part of the URL path as specified by its -/// template. A variable template must not contain other variables. If a variable -/// matches a single path segment, its template may be omitted, e.g. `{var}` -/// is equivalent to `{var=*}`. -/// -/// The syntax `LITERAL` matches literal text in the URL path. If the `LITERAL` -/// contains any reserved character, such characters should be percent-encoded -/// before the matching. -/// -/// If a variable contains exactly one path segment, such as `"{var}"` or -/// `"{var=*}"`, when such a variable is expanded into a URL path on the client -/// side, all characters except `\[-_.~0-9a-zA-Z\]` are percent-encoded. The -/// server side does the reverse decoding. Such variables show up in the -/// [Discovery -/// Document]() as -/// `{var}`. -/// -/// If a variable contains multiple path segments, such as `"{var=foo/*}"` -/// or `"{var=**}"`, when such a variable is expanded into a URL path on the -/// client side, all characters except `\[-_.~/0-9a-zA-Z\]` are percent-encoded. -/// The server side does the reverse decoding, except "%2F" and "%2f" are left -/// unchanged. Such variables show up in the -/// [Discovery -/// Document]() as -/// `{+var}`. -/// -/// ## Using gRPC API Service Configuration -/// -/// gRPC API Service Configuration (service config) is a configuration language -/// for configuring a gRPC service to become a user-facing product. The -/// service config is simply the YAML representation of the `google.api.Service` -/// proto message. -/// -/// As an alternative to annotating your proto file, you can configure gRPC -/// transcoding in your service config YAML files. You do this by specifying a -/// `HttpRule` that maps the gRPC method to a REST endpoint, achieving the same -/// effect as the proto annotation. This can be particularly useful if you -/// have a proto that is reused in multiple services. Note that any transcoding -/// specified in the service config will override any matching transcoding -/// configuration in the proto. -/// -/// Example: -/// -/// http: -/// rules: -/// # Selects a gRPC method and applies HttpRule to it. -/// - selector: example.v1.Messaging.GetMessage -/// get: /v1/messages/{message_id}/{sub.subfield} -/// -/// ## Special notes -/// -/// When gRPC Transcoding is used to map a gRPC to JSON REST endpoints, the -/// proto to JSON conversion must follow the [proto3 -/// specification](). -/// -/// While the single segment variable follows the semantics of -/// [RFC 6570]() Section 3.2.2 Simple String -/// Expansion, the multi segment variable **does not** follow RFC 6570 Section -/// 3.2.3 Reserved Expansion. The reason is that the Reserved Expansion -/// does not expand special characters like `?` and `#`, which would lead -/// to invalid URLs. As the result, gRPC Transcoding uses a custom encoding -/// for multi segment variables. -/// -/// The path variables **must not** refer to any repeated or mapped field, -/// because client libraries are not capable of handling such variable expansion. -/// -/// The path variables **must not** capture the leading "/" character. The reason -/// is that the most common use case "{var}" does not capture the leading "/" -/// character. For consistency, all path variables must share the same behavior. -/// -/// Repeated message fields must not be mapped to URL query parameters, because -/// no client library can support such complicated mapping. -/// -/// If an API needs to use a JSON array for request or response body, it can map -/// the request or response body to a repeated field. However, some gRPC -/// Transcoding implementations may not support this feature. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct HttpRule { - /// Selects a method to which this rule applies. - /// - /// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax - /// details. - #[prost(string, tag = "1")] - pub selector: ::prost::alloc::string::String, - /// The name of the request field whose value is mapped to the HTTP request - /// body, or `*` for mapping all request fields not captured by the path - /// pattern to the HTTP body, or omitted for not having any HTTP request body. - /// - /// NOTE: the referred field must be present at the top-level of the request - /// message type. - #[prost(string, tag = "7")] - pub body: ::prost::alloc::string::String, - /// Optional. The name of the response field whose value is mapped to the HTTP - /// response body. When omitted, the entire response message will be used - /// as the HTTP response body. - /// - /// NOTE: The referred field must be present at the top-level of the response - /// message type. - #[prost(string, tag = "12")] - pub response_body: ::prost::alloc::string::String, - /// Additional HTTP bindings for the selector. Nested bindings must - /// not contain an `additional_bindings` field themselves (that is, - /// the nesting may only be one level deep). - #[prost(message, repeated, tag = "11")] - pub additional_bindings: ::prost::alloc::vec::Vec, - /// Determines the URL pattern is matched by this rules. This pattern can be - /// used with any of the {get|put|post|delete|patch} methods. A custom method - /// can be defined using the 'custom' field. - #[prost(oneof = "http_rule::Pattern", tags = "2, 3, 4, 5, 6, 8")] - pub pattern: ::core::option::Option, -} -/// Nested message and enum types in `HttpRule`. -pub mod http_rule { - /// Determines the URL pattern is matched by this rules. This pattern can be - /// used with any of the {get|put|post|delete|patch} methods. A custom method - /// can be defined using the 'custom' field. - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Pattern { - /// Maps to HTTP GET. Used for listing and getting information about - /// resources. - #[prost(string, tag = "2")] - Get(::prost::alloc::string::String), - /// Maps to HTTP PUT. Used for replacing a resource. - #[prost(string, tag = "3")] - Put(::prost::alloc::string::String), - /// Maps to HTTP POST. Used for creating a resource or performing an action. - #[prost(string, tag = "4")] - Post(::prost::alloc::string::String), - /// Maps to HTTP DELETE. Used for deleting a resource. - #[prost(string, tag = "5")] - Delete(::prost::alloc::string::String), - /// Maps to HTTP PATCH. Used for updating a resource. - #[prost(string, tag = "6")] - Patch(::prost::alloc::string::String), - /// The custom pattern is used for specifying an HTTP method that is not - /// included in the `pattern` field, such as HEAD, or "*" to leave the - /// HTTP method unspecified for this rule. The wild-card rule is useful - /// for services that provide content to Web (HTML) clients. - #[prost(message, tag = "8")] - Custom(super::CustomHttpPattern), - } -} -/// A custom pattern is used for defining custom HTTP verb. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CustomHttpPattern { - /// The name of this custom HTTP verb. - #[prost(string, tag = "1")] - pub kind: ::prost::alloc::string::String, - /// The path matched by this custom verb. - #[prost(string, tag = "2")] - pub path: ::prost::alloc::string::String, -} diff --git a/crates/xmtp-networking/src/grpc_api_helper.rs b/crates/xmtp-networking/src/grpc_api_helper.rs index 17396b093..2cf6160d5 100644 --- a/crates/xmtp-networking/src/grpc_api_helper.rs +++ b/crates/xmtp-networking/src/grpc_api_helper.rs @@ -1,4 +1,4 @@ -use crate::proto_helper::xmtp::message_api::v1; +use xmtp_proto::xmtp::message_api::v1; use tonic::{metadata::MetadataValue, transport::Channel, Request}; diff --git a/crates/xmtp-networking/src/lib.rs b/crates/xmtp-networking/src/lib.rs index 37a43c045..79275a964 100644 --- a/crates/xmtp-networking/src/lib.rs +++ b/crates/xmtp-networking/src/lib.rs @@ -1,5 +1,5 @@ pub mod grpc_api_helper; -pub mod proto_helper; + // Custom patching of protobuf serialization for bytes -> base64 // https://github.com/tokio-rs/prost/issues/75#issuecomment-1383233271 pub mod serialize_utils; @@ -15,7 +15,9 @@ mod tests { let serialized = test_envelope(); assert_eq!( serialized, - "{\"content_topic\":\"\",\"timestamp_ns\":0,\"message\":\"QQ==\"}" + // NOTE: I removed the empty content_topic and timestamp_ns fields, since + // the serializer I am using doesn't include them + "{\"message\":\"QQ==\"}" ); } @@ -24,7 +26,7 @@ mod tests { let rt = tokio::runtime::Runtime::new().unwrap(); rt.block_on(async { let resp = query_serialized( - "http://localhost:15555".to_string(), + "http://localhost:5556".to_string(), "test".to_string(), "".to_string(), ) diff --git a/crates/xmtp-networking/src/proto_helper.rs b/crates/xmtp-networking/src/proto_helper.rs deleted file mode 100644 index d1a7e1380..000000000 --- a/crates/xmtp-networking/src/proto_helper.rs +++ /dev/null @@ -1,15 +0,0 @@ -pub mod xmtp { - pub mod keystore_api { - pub mod v1 { - include!("xmtp.keystore_api.v1.rs"); - } - } - pub mod message_api { - pub mod v1 { - include!("xmtp.message_api.v1.rs"); - } - } - pub mod message_contents { - include!("xmtp.message_contents.rs"); - } -} diff --git a/crates/xmtp-networking/src/xmtp.keystore_api.v1.rs b/crates/xmtp-networking/src/xmtp.keystore_api.v1.rs deleted file mode 100644 index 27280c369..000000000 --- a/crates/xmtp-networking/src/xmtp.keystore_api.v1.rs +++ /dev/null @@ -1,388 +0,0 @@ -/// Wrapper class for errors from the Keystore API -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct KeystoreError { - #[prost(string, tag = "1")] - pub message: ::prost::alloc::string::String, - #[prost(enumeration = "ErrorCode", tag = "2")] - pub code: i32, -} -/// A light pointer for a conversation that contains no decryption keys -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ConversationReference { - #[prost(string, tag = "1")] - pub topic: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub peer_address: ::prost::alloc::string::String, - #[prost(uint64, tag = "3")] - pub created_ns: u64, - #[prost(message, optional, tag = "4")] - pub context: ::core::option::Option< - super::super::message_contents::invitation_v1::Context, - >, -} -/// Decrypt a batch of messages using X3DH key agreement -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DecryptV1Request { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `DecryptV1Request`. -pub mod decrypt_v1_request { - /// A single decryption request - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Request { - #[prost(message, optional, tag = "1")] - pub payload: ::core::option::Option< - super::super::super::message_contents::Ciphertext, - >, - #[prost(message, optional, tag = "2")] - pub peer_keys: ::core::option::Option< - super::super::super::message_contents::PublicKeyBundle, - >, - #[prost(bytes = "vec", tag = "3")] - pub header_bytes: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "4")] - pub is_sender: bool, - } -} -/// Response type for both V1 and V2 decryption requests -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DecryptResponse { - #[prost(message, repeated, tag = "1")] - pub responses: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `DecryptResponse`. -pub mod decrypt_response { - /// A single decryption response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Response { - #[prost(oneof = "response::Response", tags = "1, 2")] - pub response: ::core::option::Option, - } - /// Nested message and enum types in `Response`. - pub mod response { - /// Wrapper object for success response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Success { - #[prost(bytes = "vec", tag = "1")] - pub decrypted: ::prost::alloc::vec::Vec, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Response { - #[prost(message, tag = "1")] - Result(Success), - #[prost(message, tag = "2")] - Error(super::super::KeystoreError), - } - } -} -/// Decrypt a batch of messages using the appropriate topic keys -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DecryptV2Request { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `DecryptV2Request`. -pub mod decrypt_v2_request { - /// A single decryption request - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Request { - #[prost(message, optional, tag = "1")] - pub payload: ::core::option::Option< - super::super::super::message_contents::Ciphertext, - >, - #[prost(bytes = "vec", tag = "2")] - pub header_bytes: ::prost::alloc::vec::Vec, - #[prost(string, tag = "3")] - pub content_topic: ::prost::alloc::string::String, - } -} -/// Encrypt a batch of messages using X3DH key agreement -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncryptV1Request { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `EncryptV1Request`. -pub mod encrypt_v1_request { - /// A single encryption request - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Request { - #[prost(message, optional, tag = "1")] - pub recipient: ::core::option::Option< - super::super::super::message_contents::PublicKeyBundle, - >, - #[prost(bytes = "vec", tag = "2")] - pub payload: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "3")] - pub header_bytes: ::prost::alloc::vec::Vec, - } -} -/// Response type for both V1 and V2 encryption requests -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncryptResponse { - #[prost(message, repeated, tag = "1")] - pub responses: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `EncryptResponse`. -pub mod encrypt_response { - /// A single encryption response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Response { - #[prost(oneof = "response::Response", tags = "1, 2")] - pub response: ::core::option::Option, - } - /// Nested message and enum types in `Response`. - pub mod response { - /// Wrapper object for success response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Success { - #[prost(message, optional, tag = "1")] - pub encrypted: ::core::option::Option< - super::super::super::super::message_contents::Ciphertext, - >, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Response { - #[prost(message, tag = "1")] - Result(Success), - #[prost(message, tag = "2")] - Error(super::super::KeystoreError), - } - } -} -/// Encrypt a batch of messages using the appropriate topic keys -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncryptV2Request { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `EncryptV2Request`. -pub mod encrypt_v2_request { - /// A single encryption request - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Request { - #[prost(bytes = "vec", tag = "1")] - pub payload: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "2")] - pub header_bytes: ::prost::alloc::vec::Vec, - #[prost(string, tag = "3")] - pub content_topic: ::prost::alloc::string::String, - } -} -/// Request to create an invite payload, and store the topic keys in the Keystore -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateInviteRequest { - #[prost(message, optional, tag = "1")] - pub context: ::core::option::Option< - super::super::message_contents::invitation_v1::Context, - >, - #[prost(message, optional, tag = "2")] - pub recipient: ::core::option::Option< - super::super::message_contents::SignedPublicKeyBundle, - >, - #[prost(uint64, tag = "3")] - pub created_ns: u64, -} -/// Response to a CreateInviteRequest -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateInviteResponse { - #[prost(message, optional, tag = "1")] - pub conversation: ::core::option::Option, - #[prost(bytes = "vec", tag = "2")] - pub payload: ::prost::alloc::vec::Vec, -} -/// Request to save a batch of invite messages to the Keystore -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SaveInvitesRequest { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `SaveInvitesRequest`. -pub mod save_invites_request { - /// Mirrors xmtp.envelope schema - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Request { - #[prost(string, tag = "1")] - pub content_topic: ::prost::alloc::string::String, - #[prost(uint64, tag = "2")] - pub timestamp_ns: u64, - #[prost(bytes = "vec", tag = "3")] - pub payload: ::prost::alloc::vec::Vec, - } -} -/// Response to a SaveInvitesRequest -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SaveInvitesResponse { - #[prost(message, repeated, tag = "1")] - pub responses: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `SaveInvitesResponse`. -pub mod save_invites_response { - /// A single response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Response { - #[prost(oneof = "response::Response", tags = "1, 2")] - pub response: ::core::option::Option, - } - /// Nested message and enum types in `Response`. - pub mod response { - /// Wrapper object for success response - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Success { - #[prost(message, optional, tag = "1")] - pub conversation: ::core::option::Option< - super::super::ConversationReference, - >, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Response { - #[prost(message, tag = "1")] - Result(Success), - #[prost(message, tag = "2")] - Error(super::super::KeystoreError), - } - } -} -/// CreateAuthTokenRequest is used to create an auth token for the XMTP API -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateAuthTokenRequest { - #[prost(uint64, optional, tag = "1")] - pub timestamp_ns: ::core::option::Option, -} -/// SignDigestRequest is used to sign a digest with either the identity key -/// or a prekey -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignDigestRequest { - #[prost(bytes = "vec", tag = "1")] - pub digest: ::prost::alloc::vec::Vec, - #[prost(oneof = "sign_digest_request::Signer", tags = "2, 3")] - pub signer: ::core::option::Option, -} -/// Nested message and enum types in `SignDigestRequest`. -pub mod sign_digest_request { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Signer { - #[prost(bool, tag = "2")] - IdentityKey(bool), - #[prost(uint32, tag = "3")] - PrekeyIndex(u32), - } -} -/// A mapping of topics to their decrypted invitations -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct TopicMap { - #[prost(map = "string, message", tag = "1")] - pub topics: ::std::collections::HashMap< - ::prost::alloc::string::String, - topic_map::TopicData, - >, -} -/// Nested message and enum types in `TopicMap`. -pub mod topic_map { - /// TopicData wraps the invitation and the timestamp it was created - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct TopicData { - #[prost(uint64, tag = "1")] - pub created_ns: u64, - #[prost(string, tag = "2")] - pub peer_address: ::prost::alloc::string::String, - #[prost(message, optional, tag = "3")] - pub invitation: ::core::option::Option< - super::super::super::message_contents::InvitationV1, - >, - } -} -/// Application-specific error codes for the Keystore API. -#[derive(serde::Deserialize, serde::Serialize)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum ErrorCode { - Unspecified = 0, - InvalidInput = 1, - NoMatchingPrekey = 2, -} -impl ErrorCode { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - ErrorCode::Unspecified => "ERROR_CODE_UNSPECIFIED", - ErrorCode::InvalidInput => "ERROR_CODE_INVALID_INPUT", - ErrorCode::NoMatchingPrekey => "ERROR_CODE_NO_MATCHING_PREKEY", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "ERROR_CODE_UNSPECIFIED" => Some(Self::Unspecified), - "ERROR_CODE_INVALID_INPUT" => Some(Self::InvalidInput), - "ERROR_CODE_NO_MATCHING_PREKEY" => Some(Self::NoMatchingPrekey), - _ => None, - } - } -} diff --git a/crates/xmtp-networking/src/xmtp.message_api.v1.rs b/crates/xmtp-networking/src/xmtp.message_api.v1.rs deleted file mode 100644 index 48cc27842..000000000 --- a/crates/xmtp-networking/src/xmtp.message_api.v1.rs +++ /dev/null @@ -1,812 +0,0 @@ -/// Token is used by clients to prove to the nodes -/// that they are serving a specific wallet. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Token { - /// identity key signed by a wallet - #[prost(message, optional, tag = "1")] - pub identity_key: ::core::option::Option, - /// encoded bytes of AuthData - #[prost(bytes = "vec", tag = "2")] - pub auth_data_bytes: ::prost::alloc::vec::Vec, - /// identity key signature of AuthData bytes - #[prost(message, optional, tag = "3")] - pub auth_data_signature: ::core::option::Option< - super::super::message_contents::Signature, - >, -} -/// AuthData carries token parameters that are authenticated -/// by the identity key signature. -/// It is embedded in the Token structure as bytes -/// so that the bytes don't need to be reconstructed -/// to verify the token signature. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AuthData { - /// address of the wallet - #[prost(string, tag = "1")] - pub wallet_addr: ::prost::alloc::string::String, - /// time when the token was generated/signed - #[prost(uint64, tag = "2")] - pub created_ns: u64, -} -/// This is based off of the go-waku Index type, but with the -/// receiverTime and pubsubTopic removed for simplicity. -/// Both removed fields are optional -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IndexCursor { - #[prost(bytes = "vec", tag = "1")] - #[serde(serialize_with = "crate::serialize_utils::as_base64")] - pub digest: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "2")] - pub sender_time_ns: u64, -} -/// Wrapper for potentially multiple types of cursor -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Cursor { - /// Making the cursor a one-of type, as I would like to change the way we - /// handle pagination to use a precomputed sort field. - /// This way we can handle both methods - #[prost(oneof = "cursor::Cursor", tags = "1")] - pub cursor: ::core::option::Option, -} -/// Nested message and enum types in `Cursor`. -pub mod cursor { - /// Making the cursor a one-of type, as I would like to change the way we - /// handle pagination to use a precomputed sort field. - /// This way we can handle both methods - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Cursor { - #[prost(message, tag = "1")] - Index(super::IndexCursor), - } -} -/// This is based off of the go-waku PagingInfo struct, but with the direction -/// changed to our SortDirection enum format -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PagingInfo { - /// Note: this is a uint32, while go-waku's pageSize is a uint64 - #[prost(uint32, tag = "1")] - pub limit: u32, - #[prost(message, optional, tag = "2")] - pub cursor: ::core::option::Option, - #[prost(enumeration = "SortDirection", tag = "3")] - pub direction: i32, -} -/// Envelope encapsulates a message while in transit. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Envelope { - /// The topic the message belongs to, - /// If the message includes the topic as well - /// it MUST be the same as the topic in the envelope. - #[prost(string, tag = "1")] - pub content_topic: ::prost::alloc::string::String, - /// Message creation timestamp - /// If the message includes the timestamp as well - /// it MUST be equivalent to the timestamp in the envelope. - #[prost(uint64, tag = "2")] - pub timestamp_ns: u64, - #[prost(bytes = "vec", tag = "3")] - #[serde(serialize_with = "crate::serialize_utils::as_base64")] - pub message: ::prost::alloc::vec::Vec, -} -/// Publish -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PublishRequest { - #[prost(message, repeated, tag = "1")] - pub envelopes: ::prost::alloc::vec::Vec, -} -/// Empty message as a response for Publish -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PublishResponse {} -/// Subscribe -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SubscribeRequest { - #[prost(string, repeated, tag = "1")] - pub content_topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -/// SubscribeAll -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SubscribeAllRequest {} -/// Query -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryRequest { - #[prost(string, repeated, tag = "1")] - pub content_topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(uint64, tag = "2")] - pub start_time_ns: u64, - #[prost(uint64, tag = "3")] - pub end_time_ns: u64, - #[prost(message, optional, tag = "4")] - pub paging_info: ::core::option::Option, -} -/// The response, containing envelopes, for a query -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct QueryResponse { - #[prost(message, repeated, tag = "1")] - pub envelopes: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "2")] - pub paging_info: ::core::option::Option, -} -/// BatchQuery -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct BatchQueryRequest { - #[prost(message, repeated, tag = "1")] - pub requests: ::prost::alloc::vec::Vec, -} -/// Response containing a list of QueryResponse messages -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct BatchQueryResponse { - #[prost(message, repeated, tag = "1")] - pub responses: ::prost::alloc::vec::Vec, -} -/// Sort direction -#[derive(serde::Deserialize, serde::Serialize)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum SortDirection { - Unspecified = 0, - Ascending = 1, - Descending = 2, -} -impl SortDirection { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - SortDirection::Unspecified => "SORT_DIRECTION_UNSPECIFIED", - SortDirection::Ascending => "SORT_DIRECTION_ASCENDING", - SortDirection::Descending => "SORT_DIRECTION_DESCENDING", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "SORT_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified), - "SORT_DIRECTION_ASCENDING" => Some(Self::Ascending), - "SORT_DIRECTION_DESCENDING" => Some(Self::Descending), - _ => None, - } - } -} -/// Generated client implementations. -pub mod message_api_client { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - use tonic::codegen::http::Uri; - /// RPC - #[derive(Debug, Clone)] - pub struct MessageApiClient { - inner: tonic::client::Grpc, - } - impl MessageApiClient { - /// Attempt to create a new client by connecting to a given endpoint. - pub async fn connect(dst: D) -> Result - where - D: TryInto, - D::Error: Into, - { - let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; - Ok(Self::new(conn)) - } - } - impl MessageApiClient - where - T: tonic::client::GrpcService, - T::Error: Into, - T::ResponseBody: Body + Send + 'static, - ::Error: Into + Send, - { - pub fn new(inner: T) -> Self { - let inner = tonic::client::Grpc::new(inner); - Self { inner } - } - pub fn with_origin(inner: T, origin: Uri) -> Self { - let inner = tonic::client::Grpc::with_origin(inner, origin); - Self { inner } - } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> MessageApiClient> - where - F: tonic::service::Interceptor, - T::ResponseBody: Default, - T: tonic::codegen::Service< - http::Request, - Response = http::Response< - >::ResponseBody, - >, - >, - , - >>::Error: Into + Send + Sync, - { - MessageApiClient::new(InterceptedService::new(inner, interceptor)) - } - /// Compress requests with the given encoding. - /// - /// This requires the server to support it otherwise it might respond with an - /// error. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.inner = self.inner.send_compressed(encoding); - self - } - /// Enable decompressing responses. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.inner = self.inner.accept_compressed(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.inner = self.inner.max_decoding_message_size(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.inner = self.inner.max_encoding_message_size(limit); - self - } - /// Publish messages to the network - pub async fn publish( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/xmtp.message_api.v1.MessageApi/Publish", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("xmtp.message_api.v1.MessageApi", "Publish")); - self.inner.unary(req, path, codec).await - } - /// Subscribe to a stream of new envelopes matching a predicate - pub async fn subscribe( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response>, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/xmtp.message_api.v1.MessageApi/Subscribe", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("xmtp.message_api.v1.MessageApi", "Subscribe")); - self.inner.server_streaming(req, path, codec).await - } - /// Subscribe to a stream of all messages - pub async fn subscribe_all( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response>, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/xmtp.message_api.v1.MessageApi/SubscribeAll", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert( - GrpcMethod::new("xmtp.message_api.v1.MessageApi", "SubscribeAll"), - ); - self.inner.server_streaming(req, path, codec).await - } - /// Query the store for messages - pub async fn query( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result, tonic::Status> { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/xmtp.message_api.v1.MessageApi/Query", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("xmtp.message_api.v1.MessageApi", "Query")); - self.inner.unary(req, path, codec).await - } - /// BatchQuery containing a set of queries to be processed - pub async fn batch_query( - &mut self, - request: impl tonic::IntoRequest, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - > { - self.inner - .ready() - .await - .map_err(|e| { - tonic::Status::new( - tonic::Code::Unknown, - format!("Service was not ready: {}", e.into()), - ) - })?; - let codec = tonic::codec::ProstCodec::default(); - let path = http::uri::PathAndQuery::from_static( - "/xmtp.message_api.v1.MessageApi/BatchQuery", - ); - let mut req = request.into_request(); - req.extensions_mut() - .insert(GrpcMethod::new("xmtp.message_api.v1.MessageApi", "BatchQuery")); - self.inner.unary(req, path, codec).await - } - } -} -/// Generated server implementations. -pub mod message_api_server { - #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] - use tonic::codegen::*; - /// Generated trait containing gRPC methods that should be implemented for use with MessageApiServer. - #[async_trait] - pub trait MessageApi: Send + Sync + 'static { - /// Publish messages to the network - async fn publish( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - /// Server streaming response type for the Subscribe method. - type SubscribeStream: futures_core::Stream< - Item = std::result::Result, - > - + Send - + 'static; - /// Subscribe to a stream of new envelopes matching a predicate - async fn subscribe( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - /// Server streaming response type for the SubscribeAll method. - type SubscribeAllStream: futures_core::Stream< - Item = std::result::Result, - > - + Send - + 'static; - /// Subscribe to a stream of all messages - async fn subscribe_all( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - /// Query the store for messages - async fn query( - &self, - request: tonic::Request, - ) -> std::result::Result, tonic::Status>; - /// BatchQuery containing a set of queries to be processed - async fn batch_query( - &self, - request: tonic::Request, - ) -> std::result::Result< - tonic::Response, - tonic::Status, - >; - } - /// RPC - #[derive(Debug)] - pub struct MessageApiServer { - inner: _Inner, - accept_compression_encodings: EnabledCompressionEncodings, - send_compression_encodings: EnabledCompressionEncodings, - max_decoding_message_size: Option, - max_encoding_message_size: Option, - } - struct _Inner(Arc); - impl MessageApiServer { - pub fn new(inner: T) -> Self { - Self::from_arc(Arc::new(inner)) - } - pub fn from_arc(inner: Arc) -> Self { - let inner = _Inner(inner); - Self { - inner, - accept_compression_encodings: Default::default(), - send_compression_encodings: Default::default(), - max_decoding_message_size: None, - max_encoding_message_size: None, - } - } - pub fn with_interceptor( - inner: T, - interceptor: F, - ) -> InterceptedService - where - F: tonic::service::Interceptor, - { - InterceptedService::new(Self::new(inner), interceptor) - } - /// Enable decompressing requests with the given encoding. - #[must_use] - pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.accept_compression_encodings.enable(encoding); - self - } - /// Compress responses with the given encoding, if the client supports it. - #[must_use] - pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { - self.send_compression_encodings.enable(encoding); - self - } - /// Limits the maximum size of a decoded message. - /// - /// Default: `4MB` - #[must_use] - pub fn max_decoding_message_size(mut self, limit: usize) -> Self { - self.max_decoding_message_size = Some(limit); - self - } - /// Limits the maximum size of an encoded message. - /// - /// Default: `usize::MAX` - #[must_use] - pub fn max_encoding_message_size(mut self, limit: usize) -> Self { - self.max_encoding_message_size = Some(limit); - self - } - } - impl tonic::codegen::Service> for MessageApiServer - where - T: MessageApi, - B: Body + Send + 'static, - B::Error: Into + Send + 'static, - { - type Response = http::Response; - type Error = std::convert::Infallible; - type Future = BoxFuture; - fn poll_ready( - &mut self, - _cx: &mut Context<'_>, - ) -> Poll> { - Poll::Ready(Ok(())) - } - fn call(&mut self, req: http::Request) -> Self::Future { - let inner = self.inner.clone(); - match req.uri().path() { - "/xmtp.message_api.v1.MessageApi/Publish" => { - #[allow(non_camel_case_types)] - struct PublishSvc(pub Arc); - impl< - T: MessageApi, - > tonic::server::UnaryService - for PublishSvc { - type Response = super::PublishResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { (*inner).publish(request).await }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = PublishSvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/xmtp.message_api.v1.MessageApi/Subscribe" => { - #[allow(non_camel_case_types)] - struct SubscribeSvc(pub Arc); - impl< - T: MessageApi, - > tonic::server::ServerStreamingService - for SubscribeSvc { - type Response = super::Envelope; - type ResponseStream = T::SubscribeStream; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { (*inner).subscribe(request).await }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = SubscribeSvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.server_streaming(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/xmtp.message_api.v1.MessageApi/SubscribeAll" => { - #[allow(non_camel_case_types)] - struct SubscribeAllSvc(pub Arc); - impl< - T: MessageApi, - > tonic::server::ServerStreamingService - for SubscribeAllSvc { - type Response = super::Envelope; - type ResponseStream = T::SubscribeAllStream; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { - (*inner).subscribe_all(request).await - }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = SubscribeAllSvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.server_streaming(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/xmtp.message_api.v1.MessageApi/Query" => { - #[allow(non_camel_case_types)] - struct QuerySvc(pub Arc); - impl tonic::server::UnaryService - for QuerySvc { - type Response = super::QueryResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { (*inner).query(request).await }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = QuerySvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - "/xmtp.message_api.v1.MessageApi/BatchQuery" => { - #[allow(non_camel_case_types)] - struct BatchQuerySvc(pub Arc); - impl< - T: MessageApi, - > tonic::server::UnaryService - for BatchQuerySvc { - type Response = super::BatchQueryResponse; - type Future = BoxFuture< - tonic::Response, - tonic::Status, - >; - fn call( - &mut self, - request: tonic::Request, - ) -> Self::Future { - let inner = Arc::clone(&self.0); - let fut = async move { (*inner).batch_query(request).await }; - Box::pin(fut) - } - } - let accept_compression_encodings = self.accept_compression_encodings; - let send_compression_encodings = self.send_compression_encodings; - let max_decoding_message_size = self.max_decoding_message_size; - let max_encoding_message_size = self.max_encoding_message_size; - let inner = self.inner.clone(); - let fut = async move { - let inner = inner.0; - let method = BatchQuerySvc(inner); - let codec = tonic::codec::ProstCodec::default(); - let mut grpc = tonic::server::Grpc::new(codec) - .apply_compression_config( - accept_compression_encodings, - send_compression_encodings, - ) - .apply_max_message_size_config( - max_decoding_message_size, - max_encoding_message_size, - ); - let res = grpc.unary(method, req).await; - Ok(res) - }; - Box::pin(fut) - } - _ => { - Box::pin(async move { - Ok( - http::Response::builder() - .status(200) - .header("grpc-status", "12") - .header("content-type", "application/grpc") - .body(empty_body()) - .unwrap(), - ) - }) - } - } - } - } - impl Clone for MessageApiServer { - fn clone(&self) -> Self { - let inner = self.inner.clone(); - Self { - inner, - accept_compression_encodings: self.accept_compression_encodings, - send_compression_encodings: self.send_compression_encodings, - max_decoding_message_size: self.max_decoding_message_size, - max_encoding_message_size: self.max_encoding_message_size, - } - } - } - impl Clone for _Inner { - fn clone(&self) -> Self { - Self(Arc::clone(&self.0)) - } - } - impl std::fmt::Debug for _Inner { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{:?}", self.0) - } - } - impl tonic::server::NamedService for MessageApiServer { - const NAME: &'static str = "xmtp.message_api.v1.MessageApi"; - } -} diff --git a/crates/xmtp-networking/src/xmtp.message_contents.rs b/crates/xmtp-networking/src/xmtp.message_contents.rs deleted file mode 100644 index f2baa9623..000000000 --- a/crates/xmtp-networking/src/xmtp.message_contents.rs +++ /dev/null @@ -1,727 +0,0 @@ -/// Signature represents a generalized public key signature, -/// defined as a union to support cryptographic algorithm agility. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Signature { - #[prost(oneof = "signature::Union", tags = "1, 2")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `Signature`. -pub mod signature { - /// ECDSA signature bytes and the recovery bit - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct EcdsaCompact { - /// compact representation [ R || S ], 64 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - /// recovery bit - #[prost(uint32, tag = "2")] - pub recovery: u32, - } - /// ECDSA signature bytes and the recovery bit - /// produced by xmtp-js::PublicKey.signWithWallet function, i.e. - /// EIP-191 signature of a "Create Identity" message with the key embedded. - /// Used to sign identity keys. - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct WalletEcdsaCompact { - /// compact representation [ R || S ], 64 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - /// recovery bit - #[prost(uint32, tag = "2")] - pub recovery: u32, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "1")] - EcdsaCompact(EcdsaCompact), - #[prost(message, tag = "2")] - WalletEcdsaCompact(WalletEcdsaCompact), - } -} -/// UnsignedPublicKey represents a generalized public key, -/// defined as a union to support cryptographic algorithm agility. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct UnsignedPublicKey { - #[prost(uint64, tag = "1")] - pub created_ns: u64, - #[prost(oneof = "unsigned_public_key::Union", tags = "3")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `UnsignedPublicKey`. -pub mod unsigned_public_key { - /// EC: SECP256k1 - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Secp256k1Uncompressed { - /// uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "3")] - Secp256k1Uncompressed(Secp256k1Uncompressed), - } -} -/// SignedPublicKey -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignedPublicKey { - /// embeds an UnsignedPublicKey - #[prost(bytes = "vec", tag = "1")] - pub key_bytes: ::prost::alloc::vec::Vec, - /// signs key_bytes - #[prost(message, optional, tag = "2")] - pub signature: ::core::option::Option, -} -/// PublicKeyBundle packages the cryptographic keys associated with a wallet. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignedPublicKeyBundle { - /// Identity key MUST be signed by the wallet. - #[prost(message, optional, tag = "1")] - pub identity_key: ::core::option::Option, - /// Pre-key MUST be signed by the identity key. - #[prost(message, optional, tag = "2")] - pub pre_key: ::core::option::Option, -} -/// PublicKey represents a generalized public key, -/// defined as a union to support cryptographic algorithm agility. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PublicKey { - #[prost(uint64, tag = "1")] - pub timestamp: u64, - #[prost(message, optional, tag = "2")] - pub signature: ::core::option::Option, - #[prost(oneof = "public_key::Union", tags = "3")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `PublicKey`. -pub mod public_key { - /// The key bytes - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Secp256k1Uncompressed { - /// uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "3")] - Secp256k1Uncompressed(Secp256k1Uncompressed), - } -} -/// PublicKeyBundle packages the cryptographic keys associated with a wallet, -/// both senders and recipients are identified by their key bundles. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PublicKeyBundle { - /// Identity key MUST be signed by the wallet. - #[prost(message, optional, tag = "1")] - pub identity_key: ::core::option::Option, - /// Pre-key MUST be signed by the identity key. - #[prost(message, optional, tag = "2")] - pub pre_key: ::core::option::Option, -} -/// ContentTypeId is used to identify the type of content stored in a Message. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ContentTypeId { - /// authority governing this content type - #[prost(string, tag = "1")] - pub authority_id: ::prost::alloc::string::String, - /// type identifier - #[prost(string, tag = "2")] - pub type_id: ::prost::alloc::string::String, - /// major version of the type - #[prost(uint32, tag = "3")] - pub version_major: u32, - /// minor version of the type - #[prost(uint32, tag = "4")] - pub version_minor: u32, -} -/// EncodedContent bundles the content with metadata identifying its type -/// and parameters required for correct decoding and presentation of the content. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncodedContent { - /// content type identifier used to match the payload with - /// the correct decoding machinery - #[prost(message, optional, tag = "1")] - pub r#type: ::core::option::Option, - /// optional encoding parameters required to correctly decode the content - #[prost(map = "string, string", tag = "2")] - pub parameters: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, - /// optional fallback description of the content that can be used in case - /// the client cannot decode or render the content - #[prost(string, optional, tag = "3")] - pub fallback: ::core::option::Option<::prost::alloc::string::String>, - /// optional compression; the value indicates algorithm used to - /// compress the encoded content bytes - #[prost(enumeration = "Compression", optional, tag = "5")] - pub compression: ::core::option::Option, - /// encoded content itself - #[prost(bytes = "vec", tag = "4")] - pub content: ::prost::alloc::vec::Vec, -} -/// SignedContent attaches a signature to EncodedContent. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignedContent { - /// MUST contain EncodedContent - #[prost(bytes = "vec", tag = "1")] - pub payload: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "2")] - pub sender: ::core::option::Option, - /// MUST be a signature of a concatenation of - /// the message header bytes and the payload bytes, - /// signed by the sender's pre-key. - #[prost(message, optional, tag = "3")] - pub signature: ::core::option::Option, -} -/// Recognized compression algorithms -/// protolint:disable ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH -#[derive(serde::Deserialize, serde::Serialize)] -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum Compression { - Deflate = 0, - Gzip = 1, -} -impl Compression { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - Compression::Deflate => "COMPRESSION_DEFLATE", - Compression::Gzip => "COMPRESSION_GZIP", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "COMPRESSION_DEFLATE" => Some(Self::Deflate), - "COMPRESSION_GZIP" => Some(Self::Gzip), - _ => None, - } - } -} -/// Composite is used to implement xmtp.org/composite content type -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Composite { - #[prost(message, repeated, tag = "1")] - pub parts: ::prost::alloc::vec::Vec, -} -/// Nested message and enum types in `Composite`. -pub mod composite { - /// Part represents one section of a composite message - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Part { - #[prost(oneof = "part::Element", tags = "1, 2")] - pub element: ::core::option::Option, - } - /// Nested message and enum types in `Part`. - pub mod part { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Element { - #[prost(message, tag = "1")] - Part(super::super::EncodedContent), - #[prost(message, tag = "2")] - Composite(super::super::Composite), - } - } -} -/// Ciphertext represents encrypted payload. -/// It is definited as a union to support cryptographic algorithm agility. -/// The payload is accompanied by the cryptographic parameters -/// required by the chosen encryption scheme. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Ciphertext { - #[prost(oneof = "ciphertext::Union", tags = "1")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `Ciphertext`. -pub mod ciphertext { - /// Encryption: AES256-GCM - /// Key derivation function: HKDF-SHA256 - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Aes256gcmHkdfsha256 { - /// 32 bytes - #[prost(bytes = "vec", tag = "1")] - pub hkdf_salt: ::prost::alloc::vec::Vec, - /// 12 bytes - #[prost(bytes = "vec", tag = "2")] - pub gcm_nonce: ::prost::alloc::vec::Vec, - /// encrypted payload - #[prost(bytes = "vec", tag = "3")] - pub payload: ::prost::alloc::vec::Vec, - } - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "1")] - Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), - } -} -/// SignedEciesCiphertext represents an ECIES encrypted payload and a signature -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignedEciesCiphertext { - /// serialized Ecies message - #[prost(bytes = "vec", tag = "1")] - pub ecies_bytes: ::prost::alloc::vec::Vec, - /// signature of sha256(ecies_bytes) signed with the IdentityKey - #[prost(message, optional, tag = "2")] - pub signature: ::core::option::Option, -} -/// Nested message and enum types in `SignedEciesCiphertext`. -pub mod signed_ecies_ciphertext { - /// Ecies is ciphertext encrypted using ECIES with a MAC - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Ecies { - /// 65 bytes - #[prost(bytes = "vec", tag = "1")] - pub ephemeral_public_key: ::prost::alloc::vec::Vec, - /// 16 bytes - #[prost(bytes = "vec", tag = "2")] - pub iv: ::prost::alloc::vec::Vec, - /// 32 bytes - #[prost(bytes = "vec", tag = "3")] - pub mac: ::prost::alloc::vec::Vec, - /// encrypted payload with block size of 16 - #[prost(bytes = "vec", tag = "4")] - pub ciphertext: ::prost::alloc::vec::Vec, - } -} -/// LEGACY: User key bundle V1 using PublicKeys. -/// The PublicKeys MUST be signed. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ContactBundleV1 { - #[prost(message, optional, tag = "1")] - pub key_bundle: ::core::option::Option, -} -/// User key bundle V2 using SignedPublicKeys. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ContactBundleV2 { - #[prost(message, optional, tag = "1")] - pub key_bundle: ::core::option::Option, -} -/// Versioned ContactBundle -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ContactBundle { - #[prost(oneof = "contact_bundle::Version", tags = "1, 2")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `ContactBundle`. -pub mod contact_bundle { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::ContactBundleV1), - #[prost(message, tag = "2")] - V2(super::ContactBundleV2), - } -} -/// Unsealed invitation V1 -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct InvitationV1 { - /// topic name chosen for this conversation. - /// It MUST be randomly generated bytes (length >= 32), - /// then base64 encoded without padding - #[prost(string, tag = "1")] - pub topic: ::prost::alloc::string::String, - /// A context object defining metadata - #[prost(message, optional, tag = "2")] - pub context: ::core::option::Option, - /// message encryption scheme and keys for this conversation. - #[prost(oneof = "invitation_v1::Encryption", tags = "3")] - pub encryption: ::core::option::Option, -} -/// Nested message and enum types in `InvitationV1`. -pub mod invitation_v1 { - /// Supported encryption schemes - /// AES256-GCM-HKDF-SHA256 - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Aes256gcmHkdfsha256 { - /// randomly generated key material (32 bytes) - #[prost(bytes = "vec", tag = "1")] - pub key_material: ::prost::alloc::vec::Vec, - } - /// The context type - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Context { - /// Expected to be a URI (ie xmtp.org/convo1) - #[prost(string, tag = "1")] - pub conversation_id: ::prost::alloc::string::String, - /// Key value map of additional metadata that would be exposed to - /// application developers and could be used for filtering - #[prost(map = "string, string", tag = "2")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, - } - /// message encryption scheme and keys for this conversation. - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Encryption { - /// Specify the encryption method to process the key material properly. - #[prost(message, tag = "3")] - Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), - } -} -/// Sealed Invitation V1 Header -/// Header carries information that is unencrypted, thus readable by the network -/// it is however authenticated as associated data with the AEAD scheme used -/// to encrypt the invitation body, thus providing tamper evidence. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SealedInvitationHeaderV1 { - #[prost(message, optional, tag = "1")] - pub sender: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub recipient: ::core::option::Option, - #[prost(uint64, tag = "3")] - pub created_ns: u64, -} -/// Sealed Invitation V1 -/// Invitation encrypted with key material derived from the sender's and -/// recipient's public key bundles using simplified X3DH where -/// the sender's ephemeral key is replaced with sender's pre-key. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SealedInvitationV1 { - /// encoded SealedInvitationHeaderV1 used as associated data for Ciphertext - #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted InvitationV1. - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, -} -/// Versioned Sealed Invitation -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SealedInvitation { - #[prost(oneof = "sealed_invitation::Version", tags = "1")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `SealedInvitation`. -pub mod sealed_invitation { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::SealedInvitationV1), - } -} -/// PrivateKey generalized to support different key types -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SignedPrivateKey { - /// time the key was created - #[prost(uint64, tag = "1")] - pub created_ns: u64, - /// public key for this private key - #[prost(message, optional, tag = "3")] - pub public_key: ::core::option::Option, - /// private key - #[prost(oneof = "signed_private_key::Union", tags = "2")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `SignedPrivateKey`. -pub mod signed_private_key { - /// EC: SECP256k1 - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Secp256k1 { - /// D big-endian, 32 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - } - /// private key - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "2")] - Secp256k1(Secp256k1), - } -} -/// PrivateKeyBundle wraps the identityKey and the preKeys, -/// enforces usage of signed keys. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PrivateKeyBundleV2 { - #[prost(message, optional, tag = "1")] - pub identity_key: ::core::option::Option, - /// all the known pre-keys, newer keys first, - #[prost(message, repeated, tag = "2")] - pub pre_keys: ::prost::alloc::vec::Vec, -} -/// LEGACY: PrivateKey generalized to support different key types -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PrivateKey { - /// time the key was created - #[prost(uint64, tag = "1")] - pub timestamp: u64, - /// public key for this private key - #[prost(message, optional, tag = "3")] - pub public_key: ::core::option::Option, - /// private key - #[prost(oneof = "private_key::Union", tags = "2")] - pub union: ::core::option::Option, -} -/// Nested message and enum types in `PrivateKey`. -pub mod private_key { - /// EC: SECP256k1 - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Message)] - pub struct Secp256k1 { - /// D big-endian, 32 bytes - #[prost(bytes = "vec", tag = "1")] - pub bytes: ::prost::alloc::vec::Vec, - } - /// private key - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Union { - #[prost(message, tag = "2")] - Secp256k1(Secp256k1), - } -} -/// LEGACY: PrivateKeyBundleV1 wraps the identityKey and the preKeys -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PrivateKeyBundleV1 { - #[prost(message, optional, tag = "1")] - pub identity_key: ::core::option::Option, - /// all the known pre-keys, newer keys first, - #[prost(message, repeated, tag = "2")] - pub pre_keys: ::prost::alloc::vec::Vec, -} -/// Versioned PrivateKeyBundle -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PrivateKeyBundle { - #[prost(oneof = "private_key_bundle::Version", tags = "1, 2")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `PrivateKeyBundle`. -pub mod private_key_bundle { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::PrivateKeyBundleV1), - #[prost(message, tag = "2")] - V2(super::PrivateKeyBundleV2), - } -} -/// PrivateKeyBundle encrypted with key material generated by -/// signing a randomly generated "pre-key" with the user's wallet, -/// i.e. EIP-191 signature of a "storage signature" message with -/// the pre-key embedded in it. -/// (see xmtp-js::PrivateKeyBundle.toEncryptedBytes for details) -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncryptedPrivateKeyBundleV1 { - /// randomly generated pre-key - /// - /// 32 bytes - #[prost(bytes = "vec", tag = "1")] - pub wallet_pre_key: ::prost::alloc::vec::Vec, - /// MUST contain encrypted PrivateKeyBundle - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, -} -/// Versioned encrypted PrivateKeyBundle -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EncryptedPrivateKeyBundle { - #[prost(oneof = "encrypted_private_key_bundle::Version", tags = "1")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `EncryptedPrivateKeyBundle`. -pub mod encrypted_private_key_bundle { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::EncryptedPrivateKeyBundleV1), - } -} -/// Message header is encoded separately as the bytes are also used -/// as associated data for authenticated encryption -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MessageHeaderV1 { - #[prost(message, optional, tag = "1")] - pub sender: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub recipient: ::core::option::Option, - #[prost(uint64, tag = "3")] - pub timestamp: u64, -} -/// Message is the top level protocol element -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MessageV1 { - /// encapsulates encoded MessageHeaderV1 - #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted EncodedContent - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, -} -/// Message header carries information that is not encrypted, and is therefore -/// observable by the network. It is however authenticated as associated data -/// of the AEAD encryption used to protect the message, -/// thus providing tamper evidence. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MessageHeaderV2 { - /// sender specified message creation time - #[prost(uint64, tag = "1")] - pub created_ns: u64, - /// the topic the message belongs to - #[prost(string, tag = "2")] - pub topic: ::prost::alloc::string::String, -} -/// Message combines the encoded header with the encrypted payload. -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MessageV2 { - /// encapsulates encoded MessageHeaderV2 - #[prost(bytes = "vec", tag = "1")] - pub header_bytes: ::prost::alloc::vec::Vec, - /// Ciphertext.payload MUST contain encrypted SignedContent - #[prost(message, optional, tag = "2")] - pub ciphertext: ::core::option::Option, -} -/// Versioned Message -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Message { - #[prost(oneof = "message::Version", tags = "1, 2")] - pub version: ::core::option::Option, -} -/// Nested message and enum types in `Message`. -pub mod message { - #[derive(serde::Deserialize, serde::Serialize)] - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Version { - #[prost(message, tag = "1")] - V1(super::MessageV1), - #[prost(message, tag = "2")] - V2(super::MessageV2), - } -} -/// DecodedMessage represents the decrypted message contents. -/// DecodedMessage instances are not stored on the network, but -/// may be serialized and stored by clients -#[derive(serde::Deserialize, serde::Serialize)] -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DecodedMessage { - #[prost(string, tag = "1")] - pub id: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub message_version: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub sender_address: ::prost::alloc::string::String, - #[prost(string, optional, tag = "4")] - pub recipient_address: ::core::option::Option<::prost::alloc::string::String>, - #[prost(uint64, tag = "5")] - pub sent_ns: u64, - #[prost(string, tag = "6")] - pub content_topic: ::prost::alloc::string::String, - #[prost(message, optional, tag = "7")] - pub conversation: ::core::option::Option< - super::keystore_api::v1::ConversationReference, - >, - /// encapsulates EncodedContent - #[prost(bytes = "vec", tag = "8")] - pub content_bytes: ::prost::alloc::vec::Vec, -} diff --git a/crates/xmtp-proto/.gitignore b/crates/xmtp-proto/.gitignore new file mode 100644 index 000000000..7f6e5b2b5 --- /dev/null +++ b/crates/xmtp-proto/.gitignore @@ -0,0 +1 @@ +./src/gen \ No newline at end of file diff --git a/crates/xmtp-proto/Cargo.toml b/crates/xmtp-proto/Cargo.toml new file mode 100644 index 000000000..a44a68eba --- /dev/null +++ b/crates/xmtp-proto/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "xmtp-proto" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html +[dependencies] +prost = { version = "0.11", features = ["prost-derive"] } +# Only necessary if using Protobuf well-known types: +prost-types = "0.11" +tonic = "0.9.1" +serde = "1.0.160" +pbjson = "0.5.1" +pbjson-types = "0.5.1" + +[features] +default = [] +# @@protoc_deletion_point(features) +# This section is automatically generated by protoc-gen-prost-crate. +# Changes in this area may be lost on regeneration. +proto_full = ["xmtp-keystore_api-v1","xmtp-message_api-v1","xmtp-message_contents"] +"xmtp-keystore_api-v1" = ["xmtp-message_contents"] +"xmtp-message_api-v1" = ["xmtp-message_contents"] +"xmtp-message_contents" = [] +## @@protoc_insertion_point(features) \ No newline at end of file diff --git a/crates/xmtp-proto/buf.gen.yaml b/crates/xmtp-proto/buf.gen.yaml new file mode 100644 index 000000000..9086bccf2 --- /dev/null +++ b/crates/xmtp-proto/buf.gen.yaml @@ -0,0 +1,24 @@ +version: v1 +managed: + enabled: true +plugins: + - plugin: buf.build/community/neoeinstein-prost + out: src/gen + opt: + - compile_well_known_types + - extern_path=.google.protobuf=::pbjson_types + - file_descriptor_set + - plugin: buf.build/community/neoeinstein-prost-serde + out: src/gen + - plugin: buf.build/community/neoeinstein-tonic + out: src/gen + opt: + - no_server=true + - compile_well_known_types + - extern_path=.google.protobuf=::pbjson_types + - name: prost-crate + out: . + strategy: all + opt: + - include_file=src/gen/mod.rs + - gen_crate diff --git a/crates/xmtp-proto/build.rs b/crates/xmtp-proto/build.rs new file mode 100644 index 000000000..25e99bcc3 --- /dev/null +++ b/crates/xmtp-proto/build.rs @@ -0,0 +1,42 @@ +use std::error::Error; +use std::process::{exit, Command, Stdio}; + +fn ensure_crate(crate_name: &str) { + let check_crate = Command::new("cargo") + .arg("install") + .arg("--list") + .output() + .expect("Failed to list installed crates"); + + let installed_crates = String::from_utf8_lossy(&check_crate.stdout); + if !installed_crates.contains(crate_name) { + let mut install_crate = Command::new("cargo") + .arg("install") + .arg(crate_name) + .stdout(Stdio::inherit()) + .stderr(Stdio::inherit()) + .spawn() + .expect("Failed to install crate"); + + install_crate + .wait() + .expect("Failed to wait on crate installation process"); + } +} + +fn main() -> Result<(), Box> { + ensure_crate("protoc-gen-prost-crate"); + + let status = Command::new("buf") + .arg("generate") + .arg("buf.build/xmtp/proto") + .current_dir(env!("CARGO_MANIFEST_DIR")) + .status() + .unwrap(); + + if !status.success() { + exit(status.code().unwrap_or(-1)) + } + + Ok(()) +} diff --git a/crates/xmtp-proto/src/gen/mod.rs b/crates/xmtp-proto/src/gen/mod.rs new file mode 100644 index 000000000..8c9a5828a --- /dev/null +++ b/crates/xmtp-proto/src/gen/mod.rs @@ -0,0 +1,25 @@ +// @generated +pub mod xmtp { + pub mod keystore_api { + #[cfg(feature = "xmtp-keystore_api-v1")] + // @@protoc_insertion_point(attribute:xmtp.keystore_api.v1) + pub mod v1 { + include!("xmtp.keystore_api.v1.rs"); + // @@protoc_insertion_point(xmtp.keystore_api.v1) + } + } + pub mod message_api { + #[cfg(feature = "xmtp-message_api-v1")] + // @@protoc_insertion_point(attribute:xmtp.message_api.v1) + pub mod v1 { + include!("xmtp.message_api.v1.rs"); + // @@protoc_insertion_point(xmtp.message_api.v1) + } + } + #[cfg(feature = "xmtp-message_contents")] + // @@protoc_insertion_point(attribute:xmtp.message_contents) + pub mod message_contents { + include!("xmtp.message_contents.rs"); + // @@protoc_insertion_point(xmtp.message_contents) + } +} \ No newline at end of file diff --git a/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.rs b/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.rs new file mode 100644 index 000000000..b1c55aeb1 --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.rs @@ -0,0 +1,904 @@ +// @generated +/// Wrapper class for errors from the Keystore API +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct KeystoreError { + #[prost(string, tag="1")] + pub message: ::prost::alloc::string::String, + #[prost(enumeration="ErrorCode", tag="2")] + pub code: i32, +} +/// Decrypt a batch of messages using X3DH key agreement +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptV1Request { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `DecryptV1Request`. +pub mod decrypt_v1_request { + /// A single decryption request + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + #[prost(message, optional, tag="1")] + pub payload: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub peer_keys: ::core::option::Option, + #[prost(bytes="vec", tag="3")] + pub header_bytes: ::prost::alloc::vec::Vec, + #[prost(bool, tag="4")] + pub is_sender: bool, + } +} +/// Response type for both V1 and V2 decryption requests +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptResponse { + #[prost(message, repeated, tag="1")] + pub responses: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `DecryptResponse`. +pub mod decrypt_response { + /// A single decryption response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Response { + #[prost(oneof="response::Response", tags="1, 2")] + pub response: ::core::option::Option, + } + /// Nested message and enum types in `Response`. + pub mod response { + /// Wrapper object for success response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Success { + #[prost(bytes="vec", tag="1")] + pub decrypted: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(message, tag="1")] + Result(Success), + #[prost(message, tag="2")] + Error(super::super::KeystoreError), + } + } +} +/// Decrypt a batch of messages using the appropriate topic keys +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecryptV2Request { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `DecryptV2Request`. +pub mod decrypt_v2_request { + /// A single decryption request + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + #[prost(message, optional, tag="1")] + pub payload: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub header_bytes: ::prost::alloc::vec::Vec, + #[prost(string, tag="3")] + pub content_topic: ::prost::alloc::string::String, + } +} +/// Encrypt a batch of messages using X3DH key agreement +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptV1Request { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `EncryptV1Request`. +pub mod encrypt_v1_request { + /// A single encryption request + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + #[prost(message, optional, tag="1")] + pub recipient: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub payload: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="3")] + pub header_bytes: ::prost::alloc::vec::Vec, + } +} +/// Response type for both V1 and V2 encryption requests +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptResponse { + #[prost(message, repeated, tag="1")] + pub responses: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `EncryptResponse`. +pub mod encrypt_response { + /// A single encryption response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Response { + #[prost(oneof="response::Response", tags="1, 2")] + pub response: ::core::option::Option, + } + /// Nested message and enum types in `Response`. + pub mod response { + /// Wrapper object for success response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Success { + #[prost(message, optional, tag="1")] + pub encrypted: ::core::option::Option, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(message, tag="1")] + Result(Success), + #[prost(message, tag="2")] + Error(super::super::KeystoreError), + } + } +} +/// Encrypt a batch of messages using the appropriate topic keys +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptV2Request { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `EncryptV2Request`. +pub mod encrypt_v2_request { + /// A single encryption request + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + #[prost(bytes="vec", tag="1")] + pub payload: ::prost::alloc::vec::Vec, + #[prost(bytes="vec", tag="2")] + pub header_bytes: ::prost::alloc::vec::Vec, + #[prost(string, tag="3")] + pub content_topic: ::prost::alloc::string::String, + } +} +/// Request to create an invite payload, and store the topic keys in the Keystore +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateInviteRequest { + #[prost(message, optional, tag="1")] + pub context: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub recipient: ::core::option::Option, + #[prost(uint64, tag="3")] + pub created_ns: u64, +} +/// Response to a CreateInviteRequest +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateInviteResponse { + #[prost(message, optional, tag="1")] + pub conversation: ::core::option::Option, + #[prost(bytes="vec", tag="2")] + pub payload: ::prost::alloc::vec::Vec, +} +/// Request to save a batch of invite messages to the Keystore +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SaveInvitesRequest { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `SaveInvitesRequest`. +pub mod save_invites_request { + /// Mirrors xmtp.envelope schema + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + #[prost(string, tag="1")] + pub content_topic: ::prost::alloc::string::String, + #[prost(uint64, tag="2")] + pub timestamp_ns: u64, + #[prost(bytes="vec", tag="3")] + pub payload: ::prost::alloc::vec::Vec, + } +} +/// Response to a SaveInvitesRequest +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SaveInvitesResponse { + #[prost(message, repeated, tag="1")] + pub responses: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `SaveInvitesResponse`. +pub mod save_invites_response { + /// A single response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Response { + #[prost(oneof="response::Response", tags="1, 2")] + pub response: ::core::option::Option, + } + /// Nested message and enum types in `Response`. + pub mod response { + /// Wrapper object for success response + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Success { + #[prost(message, optional, tag="1")] + pub conversation: ::core::option::Option, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Response { + #[prost(message, tag="1")] + Result(Success), + #[prost(message, tag="2")] + Error(super::super::KeystoreError), + } + } +} +/// CreateAuthTokenRequest is used to create an auth token for the XMTP API +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct CreateAuthTokenRequest { + #[prost(uint64, optional, tag="1")] + pub timestamp_ns: ::core::option::Option, +} +/// SignDigestRequest is used to sign a digest with either the identity key +/// or a prekey +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignDigestRequest { + #[prost(bytes="vec", tag="1")] + pub digest: ::prost::alloc::vec::Vec, + #[prost(oneof="sign_digest_request::Signer", tags="2, 3")] + pub signer: ::core::option::Option, +} +/// Nested message and enum types in `SignDigestRequest`. +pub mod sign_digest_request { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Signer { + #[prost(bool, tag="2")] + IdentityKey(bool), + #[prost(uint32, tag="3")] + PrekeyIndex(u32), + } +} +/// A mapping of topics to their decrypted invitations +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TopicMap { + #[prost(map="string, message", tag="1")] + pub topics: ::std::collections::HashMap<::prost::alloc::string::String, topic_map::TopicData>, +} +/// Nested message and enum types in `TopicMap`. +pub mod topic_map { + /// TopicData wraps the invitation and the timestamp it was created + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct TopicData { + #[prost(uint64, tag="1")] + pub created_ns: u64, + #[prost(string, tag="2")] + pub peer_address: ::prost::alloc::string::String, + #[prost(message, optional, tag="3")] + pub invitation: ::core::option::Option, + } +} +/// Application-specific error codes for the Keystore API. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ErrorCode { + Unspecified = 0, + InvalidInput = 1, + NoMatchingPrekey = 2, +} +impl ErrorCode { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ErrorCode::Unspecified => "ERROR_CODE_UNSPECIFIED", + ErrorCode::InvalidInput => "ERROR_CODE_INVALID_INPUT", + ErrorCode::NoMatchingPrekey => "ERROR_CODE_NO_MATCHING_PREKEY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ERROR_CODE_UNSPECIFIED" => Some(Self::Unspecified), + "ERROR_CODE_INVALID_INPUT" => Some(Self::InvalidInput), + "ERROR_CODE_NO_MATCHING_PREKEY" => Some(Self::NoMatchingPrekey), + _ => None, + } + } +} +/// Encoded file descriptor set for the `xmtp.keystore_api.v1` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0x91, 0x48, 0x0a, 0x1e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x14, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, + 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x69, 0x70, 0x68, + 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2d, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x69, 0x6e, + 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x5e, 0x0a, 0x0d, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x04, + 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x63, 0x6f, 0x64, + 0x65, 0x22, 0xac, 0x02, 0x0a, 0x10, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, 0x31, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, + 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, 0x31, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x73, 0x1a, 0xcb, 0x01, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3b, + 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, + 0x78, 0x74, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x43, 0x0a, 0x09, 0x70, + 0x65, 0x65, 0x72, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, + 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x08, 0x70, 0x65, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x73, + 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x79, + 0x74, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x22, 0xb0, 0x02, 0x0a, 0x0f, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, + 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, + 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x73, 0x1a, 0xce, 0x01, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x50, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x36, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, + 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x12, 0x3b, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, + 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x1a, 0x27, + 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x65, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x64, 0x65, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x42, 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0xef, 0x01, 0x0a, 0x10, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, + 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x73, 0x1a, 0x8e, 0x01, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x3b, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, + 0x74, 0x65, 0x78, 0x74, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x21, 0x0a, + 0x0c, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x70, 0x69, + 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x54, 0x6f, 0x70, 0x69, 0x63, 0x22, 0xed, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x56, 0x31, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, 0x08, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, + 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, 0x31, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x1a, 0x8c, 0x01, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x44, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x09, 0x72, + 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0xd3, 0x02, 0x0a, 0x0f, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x09, 0x72, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, + 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x09, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x1a, 0xf1, 0x01, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, + 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x06, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x3b, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, 0x79, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, + 0x72, 0x6f, 0x72, 0x1a, 0x4a, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x3f, + 0x0a, 0x09, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, + 0x74, 0x65, 0x78, 0x74, 0x52, 0x09, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x42, + 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xcb, 0x01, 0x0a, 0x10, + 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x4a, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, + 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x1a, 0x6b, 0x0a, 0x07, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, + 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x22, 0xc7, 0x01, 0x0a, 0x13, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x45, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, + 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x4a, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x69, + 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, + 0x69, 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, + 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x64, 0x4e, 0x73, 0x22, 0x82, 0x01, 0x0a, 0x14, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x49, 0x6e, + 0x76, 0x69, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, 0x0a, 0x0c, + 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x76, 0x65, + 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, + 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xcf, 0x01, 0x0a, 0x12, 0x53, 0x61, 0x76, + 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x4c, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x30, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, + 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x1a, 0x6b, 0x0a, + 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x21, 0x0a, + 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6e, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4e, 0x73, + 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xf0, 0x02, 0x0a, 0x13, 0x53, + 0x61, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x50, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x61, 0x76, + 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x73, 0x1a, 0x86, 0x02, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x54, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x3a, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, + 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x61, 0x76, 0x65, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, + 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x3b, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, + 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x65, + 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x05, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x1a, 0x5b, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, + 0x50, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, + 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, + 0x6e, 0x63, 0x65, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x42, 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x51, 0x0a, + 0x16, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x75, 0x74, 0x68, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x26, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x48, 0x00, 0x52, + 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4e, 0x73, 0x88, 0x01, 0x01, 0x42, + 0x0f, 0x0a, 0x0d, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6e, 0x73, + 0x22, 0x7f, 0x0a, 0x11, 0x53, 0x69, 0x67, 0x6e, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, + 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0b, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, + 0x65, 0x79, 0x12, 0x23, 0x0a, 0x0c, 0x70, 0x72, 0x65, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x00, 0x52, 0x0b, 0x70, 0x72, 0x65, 0x6b, + 0x65, 0x79, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x08, 0x0a, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x72, 0x22, 0xc8, 0x02, 0x0a, 0x08, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x4d, 0x61, 0x70, 0x12, 0x42, + 0x0a, 0x06, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x4d, 0x61, 0x70, 0x2e, 0x54, + 0x6f, 0x70, 0x69, 0x63, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x74, 0x6f, 0x70, 0x69, + 0x63, 0x73, 0x1a, 0x92, 0x01, 0x0a, 0x09, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x44, 0x61, 0x74, 0x61, + 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, + 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x65, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x12, 0x43, 0x0a, 0x0a, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x49, + 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x52, 0x0a, 0x69, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x63, 0x0a, 0x0b, 0x54, 0x6f, 0x70, 0x69, 0x63, + 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, 0x3e, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6b, + 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x54, + 0x6f, 0x70, 0x69, 0x63, 0x4d, 0x61, 0x70, 0x2e, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x44, 0x61, 0x74, + 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x2a, 0x68, 0x0a, 0x09, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x52, 0x52, + 0x4f, 0x52, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1c, 0x0a, 0x18, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x43, + 0x4f, 0x44, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x49, 0x4e, 0x50, 0x55, + 0x54, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x43, 0x4f, 0x44, + 0x45, 0x5f, 0x4e, 0x4f, 0x5f, 0x4d, 0x41, 0x54, 0x43, 0x48, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x52, + 0x45, 0x4b, 0x45, 0x59, 0x10, 0x02, 0x42, 0xc4, 0x01, 0x0a, 0x18, 0x63, 0x6f, 0x6d, 0x2e, 0x78, + 0x6d, 0x74, 0x70, 0x2e, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x42, 0x0d, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, + 0x6f, 0x2f, 0x6b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2f, 0x76, + 0x31, 0xa2, 0x02, 0x03, 0x58, 0x4b, 0x58, 0xaa, 0x02, 0x13, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4b, + 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x13, + 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x41, 0x70, 0x69, + 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1f, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4b, 0x65, 0x79, 0x73, 0x74, + 0x6f, 0x72, 0x65, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4b, 0x65, + 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x4a, 0x8c, 0x2b, + 0x0a, 0x07, 0x12, 0x05, 0x01, 0x00, 0xb2, 0x01, 0x01, 0x0a, 0x2f, 0x0a, 0x01, 0x0c, 0x12, 0x03, + 0x01, 0x00, 0x12, 0x1a, 0x25, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x03, 0x00, 0x1d, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x06, 0x00, 0x37, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x02, + 0x12, 0x03, 0x07, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x03, 0x12, 0x03, 0x08, 0x00, 0x2b, + 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0a, 0x00, 0x42, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, + 0x12, 0x03, 0x0a, 0x00, 0x42, 0x0a, 0x44, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x0e, 0x00, 0x12, + 0x01, 0x1a, 0x38, 0x20, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2d, + 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x20, 0x63, + 0x6f, 0x64, 0x65, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4b, 0x65, 0x79, + 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x41, 0x50, 0x49, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x05, + 0x00, 0x01, 0x12, 0x03, 0x0e, 0x05, 0x0e, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x0f, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, + 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x0f, 0x1d, 0x1e, + 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x10, 0x04, 0x21, 0x0a, 0x0c, 0x0a, + 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x10, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x11, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x11, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x11, + 0x24, 0x25, 0x0a, 0x3c, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x15, 0x00, 0x18, 0x01, 0x1a, 0x30, + 0x20, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x20, 0x41, 0x50, 0x49, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x15, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x16, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x16, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x16, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x16, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x17, 0x04, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x17, 0x04, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x17, 0x0e, 0x12, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x17, 0x15, 0x16, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x01, + 0x12, 0x04, 0x1b, 0x00, 0x25, 0x01, 0x1a, 0x36, 0x20, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x20, 0x61, 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x58, 0x33, 0x44, 0x48, 0x20, + 0x6b, 0x65, 0x79, 0x20, 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1b, 0x08, 0x18, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x01, + 0x03, 0x00, 0x12, 0x04, 0x1d, 0x04, 0x22, 0x05, 0x1a, 0x1d, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x1d, 0x0c, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x1e, 0x08, 0x35, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x1e, 0x08, 0x28, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x1e, 0x29, 0x30, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x1e, 0x33, 0x34, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x1f, 0x08, 0x3c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x1f, 0x08, 0x2d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x1f, 0x2e, 0x37, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x1f, 0x3a, 0x3b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x12, 0x03, 0x20, + 0x08, 0x1f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x20, + 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x20, + 0x0e, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x20, + 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x12, 0x03, 0x21, 0x08, + 0x1b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x21, 0x08, + 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x21, 0x0d, + 0x16, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x21, 0x19, + 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x24, 0x04, 0x22, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x24, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x24, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x24, 0x15, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x24, 0x20, 0x21, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x28, 0x00, + 0x37, 0x01, 0x1a, 0x36, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x56, 0x31, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x56, 0x32, 0x20, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x28, 0x08, 0x17, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x02, 0x03, 0x00, 0x12, 0x04, + 0x2a, 0x04, 0x34, 0x05, 0x1a, 0x1e, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, + 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x03, 0x00, 0x01, 0x12, 0x03, 0x2a, + 0x0c, 0x14, 0x0a, 0x35, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x03, 0x00, 0x12, 0x04, 0x2c, 0x08, + 0x2e, 0x09, 0x1a, 0x25, 0x20, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x6f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, + 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, + 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x2c, 0x10, 0x17, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x02, 0x03, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2d, 0x0c, 0x20, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x02, + 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2d, 0x0c, 0x11, 0x0a, 0x10, 0x0a, 0x09, + 0x04, 0x02, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2d, 0x12, 0x1b, 0x0a, 0x10, + 0x0a, 0x09, 0x04, 0x02, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2d, 0x1e, 0x1f, + 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x08, 0x00, 0x12, 0x04, 0x30, 0x08, 0x33, 0x09, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x30, 0x0e, 0x16, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x31, 0x0c, 0x1f, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x31, 0x0c, 0x13, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x31, 0x14, 0x1a, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x31, 0x1d, 0x1e, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x32, 0x0c, 0x24, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x32, 0x0c, 0x19, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x32, 0x1a, 0x1f, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x32, 0x22, 0x23, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x36, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x04, 0x12, 0x03, 0x36, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x36, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x36, 0x16, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x36, 0x22, 0x23, 0x0a, 0x4a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x3a, 0x00, 0x43, 0x01, 0x1a, + 0x3e, 0x20, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x20, 0x61, 0x20, 0x62, 0x61, 0x74, 0x63, + 0x68, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x75, 0x73, + 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, + 0x61, 0x74, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x3a, 0x08, 0x18, 0x0a, 0x2b, 0x0a, 0x04, 0x04, + 0x03, 0x03, 0x00, 0x12, 0x04, 0x3c, 0x04, 0x40, 0x05, 0x1a, 0x1d, 0x20, 0x41, 0x20, 0x73, 0x69, + 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x03, 0x00, + 0x01, 0x12, 0x03, 0x3c, 0x0c, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x3d, 0x08, 0x35, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, 0x06, + 0x12, 0x03, 0x3d, 0x08, 0x28, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x3d, 0x29, 0x30, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x3d, 0x33, 0x34, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x3e, 0x08, 0x1f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x3e, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x3e, 0x0e, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x3e, 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x3f, 0x08, 0x21, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, + 0x3f, 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x3f, 0x0f, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, + 0x3f, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x42, 0x04, 0x22, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x04, 0x12, 0x03, 0x42, 0x04, 0x0c, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x42, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x42, 0x15, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x42, 0x20, 0x21, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, + 0x46, 0x00, 0x4f, 0x01, 0x1a, 0x36, 0x20, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x20, 0x61, + 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x73, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x58, 0x33, 0x44, 0x48, 0x20, 0x6b, 0x65, + 0x79, 0x20, 0x61, 0x67, 0x72, 0x65, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x04, 0x01, 0x12, 0x03, 0x46, 0x08, 0x18, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x04, 0x03, 0x00, + 0x12, 0x04, 0x48, 0x04, 0x4c, 0x05, 0x1a, 0x1d, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, + 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x03, 0x00, 0x01, 0x12, 0x03, + 0x48, 0x0c, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x49, + 0x08, 0x3c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x49, + 0x08, 0x2d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x49, + 0x2e, 0x37, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x49, + 0x3a, 0x3b, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x4a, 0x08, + 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x4a, 0x08, + 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x4a, 0x0e, + 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4a, 0x18, + 0x19, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x04, 0x03, 0x00, 0x02, 0x02, 0x12, 0x03, 0x4b, 0x08, 0x1f, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x4b, 0x08, 0x0d, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4b, 0x0e, 0x1a, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x04, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4b, 0x1d, 0x1e, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x4e, 0x04, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, 0x4e, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x00, 0x06, 0x12, 0x03, 0x4e, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x4e, 0x15, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x4e, 0x20, 0x21, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x52, 0x00, 0x61, + 0x01, 0x1a, 0x36, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x56, 0x31, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x56, 0x32, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, + 0x12, 0x03, 0x52, 0x08, 0x17, 0x0a, 0x2c, 0x0a, 0x04, 0x04, 0x05, 0x03, 0x00, 0x12, 0x04, 0x54, + 0x04, 0x5e, 0x05, 0x1a, 0x1e, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x65, + 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x03, 0x00, 0x01, 0x12, 0x03, 0x54, 0x0c, + 0x14, 0x0a, 0x35, 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, 0x03, 0x00, 0x12, 0x04, 0x56, 0x08, 0x58, + 0x09, 0x1a, 0x25, 0x20, 0x57, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, + 0x03, 0x00, 0x01, 0x12, 0x03, 0x56, 0x10, 0x17, 0x0a, 0x0f, 0x0a, 0x08, 0x04, 0x05, 0x03, 0x00, + 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x57, 0x0c, 0x3b, 0x0a, 0x10, 0x0a, 0x09, 0x04, 0x05, 0x03, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x57, 0x0c, 0x2c, 0x0a, 0x10, 0x0a, 0x09, 0x04, + 0x05, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x57, 0x2d, 0x36, 0x0a, 0x10, 0x0a, + 0x09, 0x04, 0x05, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x57, 0x39, 0x3a, 0x0a, + 0x0e, 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, 0x08, 0x00, 0x12, 0x04, 0x5a, 0x08, 0x5d, 0x09, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x5a, 0x0e, 0x16, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x5b, 0x0c, 0x1f, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x5b, 0x0c, 0x13, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x5b, 0x14, 0x1a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x5b, 0x1d, 0x1e, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x5c, 0x0c, 0x24, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x5c, 0x0c, 0x19, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x5c, 0x1a, 0x1f, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x05, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5c, 0x22, 0x23, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, 0x03, 0x60, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x60, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x60, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x60, 0x16, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x60, + 0x22, 0x23, 0x0a, 0x4a, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x64, 0x00, 0x6d, 0x01, 0x1a, 0x3e, + 0x20, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x20, 0x61, 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, + 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x75, 0x73, 0x69, + 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x61, 0x70, 0x70, 0x72, 0x6f, 0x70, 0x72, 0x69, 0x61, + 0x74, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x0a, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x64, 0x08, 0x18, 0x0a, 0x2b, 0x0a, 0x04, 0x04, 0x06, + 0x03, 0x00, 0x12, 0x04, 0x66, 0x04, 0x6a, 0x05, 0x1a, 0x1d, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x66, 0x0c, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x06, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x67, 0x08, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x67, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x67, 0x0e, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x67, 0x18, 0x19, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x06, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x68, 0x08, 0x1f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, + 0x68, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x68, 0x0e, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x68, 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x06, 0x03, 0x00, 0x02, 0x02, 0x12, 0x03, 0x69, + 0x08, 0x21, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x69, + 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x69, + 0x0f, 0x1c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x06, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x69, + 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, 0x12, 0x03, 0x6c, 0x04, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x03, 0x6c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, 0x03, 0x6c, 0x0d, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6c, 0x15, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x6c, 0x20, 0x21, 0x0a, 0x5b, 0x0a, 0x02, 0x04, 0x07, 0x12, 0x04, 0x70, + 0x00, 0x74, 0x01, 0x1a, 0x4f, 0x20, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, + 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x76, 0x69, 0x74, + 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2c, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, + 0x74, 0x6f, 0x72, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x6b, + 0x65, 0x79, 0x73, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x4b, 0x65, 0x79, 0x73, 0x74, + 0x6f, 0x72, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, 0x12, 0x03, 0x70, 0x08, 0x1b, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x00, 0x12, 0x03, 0x71, 0x04, 0x3b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x07, 0x02, 0x00, 0x06, 0x12, 0x03, 0x71, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x00, 0x01, 0x12, 0x03, 0x71, 0x2f, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x71, 0x39, 0x3a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x07, 0x02, 0x01, 0x12, + 0x03, 0x72, 0x04, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x06, 0x12, 0x03, 0x72, + 0x04, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x01, 0x12, 0x03, 0x72, 0x30, 0x39, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x01, 0x03, 0x12, 0x03, 0x72, 0x3c, 0x3d, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x07, 0x02, 0x02, 0x12, 0x03, 0x73, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x07, 0x02, 0x02, 0x05, 0x12, 0x03, 0x73, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x73, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x07, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x73, 0x18, 0x19, 0x0a, 0x2f, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x77, 0x00, 0x7a, + 0x01, 0x1a, 0x23, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x74, 0x6f, 0x20, + 0x61, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, 0x01, 0x12, 0x03, 0x77, + 0x08, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, 0x78, 0x04, 0x41, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x06, 0x12, 0x03, 0x78, 0x04, 0x2f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x78, 0x30, 0x3c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x78, 0x3f, 0x40, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x01, 0x12, 0x03, 0x79, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x79, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, 0x03, 0x79, + 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x79, 0x14, 0x15, + 0x0a, 0x49, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x05, 0x7d, 0x00, 0x86, 0x01, 0x01, 0x1a, 0x3c, 0x20, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x61, 0x76, 0x65, 0x20, + 0x61, 0x20, 0x62, 0x61, 0x74, 0x63, 0x68, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x6e, 0x76, 0x69, 0x74, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x4b, 0x65, 0x79, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x09, 0x01, 0x12, 0x03, 0x7d, 0x08, 0x1a, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x09, 0x03, 0x00, 0x12, + 0x05, 0x7f, 0x04, 0x83, 0x01, 0x05, 0x1a, 0x1e, 0x20, 0x4d, 0x69, 0x72, 0x72, 0x6f, 0x72, 0x73, + 0x20, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x20, 0x73, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x03, 0x00, 0x01, 0x12, + 0x03, 0x7f, 0x0c, 0x13, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, + 0x80, 0x01, 0x08, 0x21, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, + 0x04, 0x80, 0x01, 0x08, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x04, 0x80, 0x01, 0x0f, 0x1c, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x80, 0x01, 0x1f, 0x20, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, 0x03, 0x00, 0x02, + 0x01, 0x12, 0x04, 0x81, 0x01, 0x08, 0x20, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, 0x00, 0x02, + 0x01, 0x05, 0x12, 0x04, 0x81, 0x01, 0x08, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x04, 0x81, 0x01, 0x0f, 0x1b, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, 0x03, + 0x00, 0x02, 0x01, 0x03, 0x12, 0x04, 0x81, 0x01, 0x1e, 0x1f, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x09, + 0x03, 0x00, 0x02, 0x02, 0x12, 0x04, 0x82, 0x01, 0x08, 0x1a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x09, + 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x04, 0x82, 0x01, 0x08, 0x0d, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x09, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0x82, 0x01, 0x0e, 0x15, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x09, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x04, 0x82, 0x01, 0x18, 0x19, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x09, 0x02, 0x00, 0x12, 0x04, 0x85, 0x01, 0x04, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x00, 0x04, 0x12, 0x04, 0x85, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x85, 0x01, 0x0d, 0x14, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x85, 0x01, 0x15, 0x1d, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x85, 0x01, 0x20, 0x21, 0x0a, 0x30, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0x89, + 0x01, 0x00, 0x98, 0x01, 0x01, 0x1a, 0x22, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x53, 0x61, 0x76, 0x65, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, + 0x12, 0x04, 0x89, 0x01, 0x08, 0x1b, 0x0a, 0x23, 0x0a, 0x04, 0x04, 0x0a, 0x03, 0x00, 0x12, 0x06, + 0x8b, 0x01, 0x04, 0x95, 0x01, 0x05, 0x1a, 0x13, 0x20, 0x41, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, + 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x03, 0x00, 0x01, 0x12, 0x04, 0x8b, 0x01, 0x0c, 0x14, 0x0a, 0x37, 0x0a, 0x06, 0x04, 0x0a, + 0x03, 0x00, 0x03, 0x00, 0x12, 0x06, 0x8d, 0x01, 0x08, 0x8f, 0x01, 0x09, 0x1a, 0x25, 0x20, 0x57, + 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x0a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x03, 0x00, 0x01, 0x12, 0x04, + 0x8d, 0x01, 0x10, 0x17, 0x0a, 0x10, 0x0a, 0x08, 0x04, 0x0a, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, + 0x12, 0x04, 0x8e, 0x01, 0x0c, 0x49, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0a, 0x03, 0x00, 0x03, 0x00, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x8e, 0x01, 0x0c, 0x37, 0x0a, 0x11, 0x0a, 0x09, 0x04, 0x0a, 0x03, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0x8e, 0x01, 0x38, 0x44, 0x0a, 0x11, 0x0a, 0x09, + 0x04, 0x0a, 0x03, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x04, 0x8e, 0x01, 0x47, 0x48, 0x0a, + 0x10, 0x0a, 0x06, 0x04, 0x0a, 0x03, 0x00, 0x08, 0x00, 0x12, 0x06, 0x91, 0x01, 0x08, 0x94, 0x01, + 0x09, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x08, 0x00, 0x01, 0x12, 0x04, 0x91, 0x01, + 0x0e, 0x16, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x00, 0x12, 0x04, 0x92, 0x01, + 0x0c, 0x1f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x00, 0x06, 0x12, 0x04, 0x92, + 0x01, 0x0c, 0x13, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, + 0x92, 0x01, 0x14, 0x1a, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x04, 0x92, 0x01, 0x1d, 0x1e, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x01, 0x12, + 0x04, 0x93, 0x01, 0x0c, 0x24, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x01, 0x06, + 0x12, 0x04, 0x93, 0x01, 0x0c, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x04, 0x93, 0x01, 0x1a, 0x1f, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0a, 0x03, 0x00, 0x02, + 0x01, 0x03, 0x12, 0x04, 0x93, 0x01, 0x22, 0x23, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, + 0x12, 0x04, 0x97, 0x01, 0x04, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, + 0x04, 0x97, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, + 0x97, 0x01, 0x0d, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x97, + 0x01, 0x16, 0x1f, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0x97, 0x01, + 0x22, 0x23, 0x0a, 0x57, 0x0a, 0x02, 0x04, 0x0b, 0x12, 0x06, 0x9b, 0x01, 0x00, 0x9d, 0x01, 0x01, + 0x1a, 0x49, 0x20, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x41, 0x75, 0x74, 0x68, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x61, + 0x75, 0x74, 0x68, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x58, 0x4d, 0x54, 0x50, 0x20, 0x41, 0x50, 0x49, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, + 0x0b, 0x01, 0x12, 0x04, 0x9b, 0x01, 0x08, 0x1e, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0b, 0x02, 0x00, + 0x12, 0x04, 0x9c, 0x01, 0x04, 0x25, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x04, 0x12, + 0x04, 0x9c, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x05, 0x12, 0x04, + 0x9c, 0x01, 0x0d, 0x13, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x01, 0x12, 0x04, 0x9c, + 0x01, 0x14, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, 0x03, 0x12, 0x04, 0x9c, 0x01, + 0x23, 0x24, 0x0a, 0x64, 0x0a, 0x02, 0x04, 0x0c, 0x12, 0x06, 0xa1, 0x01, 0x00, 0xa7, 0x01, 0x01, + 0x1a, 0x56, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x73, 0x69, 0x67, 0x6e, 0x20, 0x61, 0x20, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x65, 0x69, 0x74, 0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x20, 0x6f, 0x72, 0x20, 0x61, + 0x20, 0x70, 0x72, 0x65, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0c, 0x01, 0x12, + 0x04, 0xa1, 0x01, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x00, 0x12, 0x04, 0xa2, + 0x01, 0x04, 0x15, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x05, 0x12, 0x04, 0xa2, 0x01, + 0x04, 0x09, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x01, 0x12, 0x04, 0xa2, 0x01, 0x0a, + 0x10, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x00, 0x03, 0x12, 0x04, 0xa2, 0x01, 0x13, 0x14, + 0x0a, 0x0e, 0x0a, 0x04, 0x04, 0x0c, 0x08, 0x00, 0x12, 0x06, 0xa3, 0x01, 0x04, 0xa6, 0x01, 0x05, + 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x08, 0x00, 0x01, 0x12, 0x04, 0xa3, 0x01, 0x0a, 0x10, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x0c, 0x02, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x08, 0x1e, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0c, 0x02, 0x01, 0x05, 0x12, 0x04, 0xa4, 0x01, 0x08, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0c, 0x02, 0x01, 0x01, 0x12, 0x04, 0xa4, 0x01, 0x0d, 0x19, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0c, 0x02, 0x01, 0x03, 0x12, 0x04, 0xa4, 0x01, 0x1c, 0x1d, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0c, + 0x02, 0x02, 0x12, 0x04, 0xa5, 0x01, 0x08, 0x20, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, + 0x05, 0x12, 0x04, 0xa5, 0x01, 0x08, 0x0e, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x01, + 0x12, 0x04, 0xa5, 0x01, 0x0f, 0x1b, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0c, 0x02, 0x02, 0x03, 0x12, + 0x04, 0xa5, 0x01, 0x1e, 0x1f, 0x0a, 0x42, 0x0a, 0x02, 0x04, 0x0d, 0x12, 0x06, 0xaa, 0x01, 0x00, + 0xb2, 0x01, 0x01, 0x1a, 0x34, 0x20, 0x41, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, + 0x69, 0x72, 0x20, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0d, 0x01, + 0x12, 0x04, 0xaa, 0x01, 0x08, 0x10, 0x0a, 0x51, 0x0a, 0x04, 0x04, 0x0d, 0x03, 0x00, 0x12, 0x06, + 0xac, 0x01, 0x04, 0xb0, 0x01, 0x05, 0x1a, 0x41, 0x20, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x44, 0x61, + 0x74, 0x61, 0x20, 0x77, 0x72, 0x61, 0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x69, 0x74, 0x20, 0x77, 0x61, 0x73, + 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x03, + 0x00, 0x01, 0x12, 0x04, 0xac, 0x01, 0x0c, 0x15, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x0d, 0x03, 0x00, + 0x02, 0x00, 0x12, 0x04, 0xad, 0x01, 0x08, 0x1e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x03, 0x00, + 0x02, 0x00, 0x05, 0x12, 0x04, 0xad, 0x01, 0x08, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x03, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x04, 0xad, 0x01, 0x0f, 0x19, 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, + 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x04, 0xad, 0x01, 0x1c, 0x1d, 0x0a, 0x0e, 0x0a, 0x06, 0x04, + 0x0d, 0x03, 0x00, 0x02, 0x01, 0x12, 0x04, 0xae, 0x01, 0x08, 0x20, 0x0a, 0x0f, 0x0a, 0x07, 0x04, + 0x0d, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x04, 0xae, 0x01, 0x08, 0x0e, 0x0a, 0x0f, 0x0a, 0x07, + 0x04, 0x0d, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x04, 0xae, 0x01, 0x0f, 0x1b, 0x0a, 0x0f, 0x0a, + 0x07, 0x04, 0x0d, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x04, 0xae, 0x01, 0x1e, 0x1f, 0x0a, 0x0e, + 0x0a, 0x06, 0x04, 0x0d, 0x03, 0x00, 0x02, 0x02, 0x12, 0x04, 0xaf, 0x01, 0x08, 0x3a, 0x0a, 0x0f, + 0x0a, 0x07, 0x04, 0x0d, 0x03, 0x00, 0x02, 0x02, 0x06, 0x12, 0x04, 0xaf, 0x01, 0x08, 0x2a, 0x0a, + 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x04, 0xaf, 0x01, 0x2b, 0x35, + 0x0a, 0x0f, 0x0a, 0x07, 0x04, 0x0d, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x04, 0xaf, 0x01, 0x38, + 0x39, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0d, 0x02, 0x00, 0x12, 0x04, 0xb1, 0x01, 0x04, 0x26, 0x0a, + 0x0d, 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x06, 0x12, 0x04, 0xb1, 0x01, 0x04, 0x1a, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0d, 0x02, 0x00, 0x01, 0x12, 0x04, 0xb1, 0x01, 0x1b, 0x21, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0d, 0x02, 0x00, 0x03, 0x12, 0x04, 0xb1, 0x01, 0x24, 0x25, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, +]; +include!("xmtp.keystore_api.v1.serde.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.serde.rs b/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.serde.rs new file mode 100644 index 000000000..1e8b37395 --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.keystore_api.v1.serde.rs @@ -0,0 +1,2867 @@ +// @generated +impl serde::Serialize for CreateAuthTokenRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.timestamp_ns.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.CreateAuthTokenRequest", len)?; + if let Some(v) = self.timestamp_ns.as_ref() { + struct_ser.serialize_field("timestampNs", ToString::to_string(&v).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateAuthTokenRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timestamp_ns", + "timestampNs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + TimestampNs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timestampNs" | "timestamp_ns" => Ok(GeneratedField::TimestampNs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateAuthTokenRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.CreateAuthTokenRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timestamp_ns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::TimestampNs => { + if timestamp_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampNs")); + } + timestamp_ns__ = + map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0) + ; + } + } + } + Ok(CreateAuthTokenRequest { + timestamp_ns: timestamp_ns__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.CreateAuthTokenRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateInviteRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.context.is_some() { + len += 1; + } + if self.recipient.is_some() { + len += 1; + } + if self.created_ns != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.CreateInviteRequest", len)?; + if let Some(v) = self.context.as_ref() { + struct_ser.serialize_field("context", v)?; + } + if let Some(v) = self.recipient.as_ref() { + struct_ser.serialize_field("recipient", v)?; + } + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateInviteRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "context", + "recipient", + "created_ns", + "createdNs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Context, + Recipient, + CreatedNs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "context" => Ok(GeneratedField::Context), + "recipient" => Ok(GeneratedField::Recipient), + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateInviteRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.CreateInviteRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut context__ = None; + let mut recipient__ = None; + let mut created_ns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Context => { + if context__.is_some() { + return Err(serde::de::Error::duplicate_field("context")); + } + context__ = map.next_value()?; + } + GeneratedField::Recipient => { + if recipient__.is_some() { + return Err(serde::de::Error::duplicate_field("recipient")); + } + recipient__ = map.next_value()?; + } + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(CreateInviteRequest { + context: context__, + recipient: recipient__, + created_ns: created_ns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.CreateInviteRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for CreateInviteResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.conversation.is_some() { + len += 1; + } + if !self.payload.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.CreateInviteResponse", len)?; + if let Some(v) = self.conversation.as_ref() { + struct_ser.serialize_field("conversation", v)?; + } + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for CreateInviteResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "conversation", + "payload", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Conversation, + Payload, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "conversation" => Ok(GeneratedField::Conversation), + "payload" => Ok(GeneratedField::Payload), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = CreateInviteResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.CreateInviteResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut conversation__ = None; + let mut payload__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Conversation => { + if conversation__.is_some() { + return Err(serde::de::Error::duplicate_field("conversation")); + } + conversation__ = map.next_value()?; + } + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(CreateInviteResponse { + conversation: conversation__, + payload: payload__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.CreateInviteResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DecryptResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.responses.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptResponse", len)?; + if !self.responses.is_empty() { + struct_ser.serialize_field("responses", &self.responses)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DecryptResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "responses", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Responses, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "responses" => Ok(GeneratedField::Responses), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DecryptResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut responses__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Responses => { + if responses__.is_some() { + return Err(serde::de::Error::duplicate_field("responses")); + } + responses__ = Some(map.next_value()?); + } + } + } + Ok(DecryptResponse { + responses: responses__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for decrypt_response::Response { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.response.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptResponse.Response", len)?; + if let Some(v) = self.response.as_ref() { + match v { + decrypt_response::response::Response::Result(v) => { + struct_ser.serialize_field("result", v)?; + } + decrypt_response::response::Response::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for decrypt_response::Response { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + "error", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + Error, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "result" => Ok(GeneratedField::Result), + "error" => Ok(GeneratedField::Error), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = decrypt_response::Response; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptResponse.Response") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut response__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Result => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("result")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(decrypt_response::response::Response::Result) +; + } + GeneratedField::Error => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(decrypt_response::response::Response::Error) +; + } + } + } + Ok(decrypt_response::Response { + response: response__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptResponse.Response", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for decrypt_response::response::Success { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.decrypted.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptResponse.Response.Success", len)?; + if !self.decrypted.is_empty() { + struct_ser.serialize_field("decrypted", pbjson::private::base64::encode(&self.decrypted).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for decrypt_response::response::Success { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "decrypted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Decrypted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "decrypted" => Ok(GeneratedField::Decrypted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = decrypt_response::response::Success; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptResponse.Response.Success") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut decrypted__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Decrypted => { + if decrypted__.is_some() { + return Err(serde::de::Error::duplicate_field("decrypted")); + } + decrypted__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(decrypt_response::response::Success { + decrypted: decrypted__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptResponse.Response.Success", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DecryptV1Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptV1Request", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DecryptV1Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DecryptV1Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptV1Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(DecryptV1Request { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptV1Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for decrypt_v1_request::Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.payload.is_some() { + len += 1; + } + if self.peer_keys.is_some() { + len += 1; + } + if !self.header_bytes.is_empty() { + len += 1; + } + if self.is_sender { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptV1Request.Request", len)?; + if let Some(v) = self.payload.as_ref() { + struct_ser.serialize_field("payload", v)?; + } + if let Some(v) = self.peer_keys.as_ref() { + struct_ser.serialize_field("peerKeys", v)?; + } + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if self.is_sender { + struct_ser.serialize_field("isSender", &self.is_sender)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for decrypt_v1_request::Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "payload", + "peer_keys", + "peerKeys", + "header_bytes", + "headerBytes", + "is_sender", + "isSender", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Payload, + PeerKeys, + HeaderBytes, + IsSender, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "payload" => Ok(GeneratedField::Payload), + "peerKeys" | "peer_keys" => Ok(GeneratedField::PeerKeys), + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "isSender" | "is_sender" => Ok(GeneratedField::IsSender), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = decrypt_v1_request::Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptV1Request.Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + let mut peer_keys__ = None; + let mut header_bytes__ = None; + let mut is_sender__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = map.next_value()?; + } + GeneratedField::PeerKeys => { + if peer_keys__.is_some() { + return Err(serde::de::Error::duplicate_field("peerKeys")); + } + peer_keys__ = map.next_value()?; + } + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::IsSender => { + if is_sender__.is_some() { + return Err(serde::de::Error::duplicate_field("isSender")); + } + is_sender__ = Some(map.next_value()?); + } + } + } + Ok(decrypt_v1_request::Request { + payload: payload__, + peer_keys: peer_keys__, + header_bytes: header_bytes__.unwrap_or_default(), + is_sender: is_sender__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptV1Request.Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DecryptV2Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptV2Request", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DecryptV2Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DecryptV2Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptV2Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(DecryptV2Request { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptV2Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for decrypt_v2_request::Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.payload.is_some() { + len += 1; + } + if !self.header_bytes.is_empty() { + len += 1; + } + if !self.content_topic.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.DecryptV2Request.Request", len)?; + if let Some(v) = self.payload.as_ref() { + struct_ser.serialize_field("payload", v)?; + } + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if !self.content_topic.is_empty() { + struct_ser.serialize_field("contentTopic", &self.content_topic)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for decrypt_v2_request::Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "payload", + "header_bytes", + "headerBytes", + "content_topic", + "contentTopic", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Payload, + HeaderBytes, + ContentTopic, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "payload" => Ok(GeneratedField::Payload), + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "contentTopic" | "content_topic" => Ok(GeneratedField::ContentTopic), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = decrypt_v2_request::Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.DecryptV2Request.Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + let mut header_bytes__ = None; + let mut content_topic__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = map.next_value()?; + } + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ContentTopic => { + if content_topic__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopic")); + } + content_topic__ = Some(map.next_value()?); + } + } + } + Ok(decrypt_v2_request::Request { + payload: payload__, + header_bytes: header_bytes__.unwrap_or_default(), + content_topic: content_topic__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.DecryptV2Request.Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncryptResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.responses.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptResponse", len)?; + if !self.responses.is_empty() { + struct_ser.serialize_field("responses", &self.responses)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncryptResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "responses", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Responses, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "responses" => Ok(GeneratedField::Responses), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncryptResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut responses__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Responses => { + if responses__.is_some() { + return Err(serde::de::Error::duplicate_field("responses")); + } + responses__ = Some(map.next_value()?); + } + } + } + Ok(EncryptResponse { + responses: responses__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for encrypt_response::Response { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.response.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptResponse.Response", len)?; + if let Some(v) = self.response.as_ref() { + match v { + encrypt_response::response::Response::Result(v) => { + struct_ser.serialize_field("result", v)?; + } + encrypt_response::response::Response::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for encrypt_response::Response { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + "error", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + Error, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "result" => Ok(GeneratedField::Result), + "error" => Ok(GeneratedField::Error), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = encrypt_response::Response; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptResponse.Response") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut response__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Result => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("result")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(encrypt_response::response::Response::Result) +; + } + GeneratedField::Error => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(encrypt_response::response::Response::Error) +; + } + } + } + Ok(encrypt_response::Response { + response: response__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptResponse.Response", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for encrypt_response::response::Success { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.encrypted.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptResponse.Response.Success", len)?; + if let Some(v) = self.encrypted.as_ref() { + struct_ser.serialize_field("encrypted", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for encrypt_response::response::Success { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "encrypted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Encrypted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "encrypted" => Ok(GeneratedField::Encrypted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = encrypt_response::response::Success; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptResponse.Response.Success") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut encrypted__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Encrypted => { + if encrypted__.is_some() { + return Err(serde::de::Error::duplicate_field("encrypted")); + } + encrypted__ = map.next_value()?; + } + } + } + Ok(encrypt_response::response::Success { + encrypted: encrypted__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptResponse.Response.Success", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncryptV1Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptV1Request", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncryptV1Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncryptV1Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptV1Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(EncryptV1Request { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptV1Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for encrypt_v1_request::Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.recipient.is_some() { + len += 1; + } + if !self.payload.is_empty() { + len += 1; + } + if !self.header_bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptV1Request.Request", len)?; + if let Some(v) = self.recipient.as_ref() { + struct_ser.serialize_field("recipient", v)?; + } + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for encrypt_v1_request::Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "recipient", + "payload", + "header_bytes", + "headerBytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Recipient, + Payload, + HeaderBytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "recipient" => Ok(GeneratedField::Recipient), + "payload" => Ok(GeneratedField::Payload), + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = encrypt_v1_request::Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptV1Request.Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut recipient__ = None; + let mut payload__ = None; + let mut header_bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Recipient => { + if recipient__.is_some() { + return Err(serde::de::Error::duplicate_field("recipient")); + } + recipient__ = map.next_value()?; + } + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(encrypt_v1_request::Request { + recipient: recipient__, + payload: payload__.unwrap_or_default(), + header_bytes: header_bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptV1Request.Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncryptV2Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptV2Request", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncryptV2Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncryptV2Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptV2Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(EncryptV2Request { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptV2Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for encrypt_v2_request::Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.payload.is_empty() { + len += 1; + } + if !self.header_bytes.is_empty() { + len += 1; + } + if !self.content_topic.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.EncryptV2Request.Request", len)?; + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if !self.content_topic.is_empty() { + struct_ser.serialize_field("contentTopic", &self.content_topic)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for encrypt_v2_request::Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "payload", + "header_bytes", + "headerBytes", + "content_topic", + "contentTopic", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Payload, + HeaderBytes, + ContentTopic, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "payload" => Ok(GeneratedField::Payload), + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "contentTopic" | "content_topic" => Ok(GeneratedField::ContentTopic), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = encrypt_v2_request::Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.EncryptV2Request.Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + let mut header_bytes__ = None; + let mut content_topic__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::ContentTopic => { + if content_topic__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopic")); + } + content_topic__ = Some(map.next_value()?); + } + } + } + Ok(encrypt_v2_request::Request { + payload: payload__.unwrap_or_default(), + header_bytes: header_bytes__.unwrap_or_default(), + content_topic: content_topic__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.EncryptV2Request.Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ErrorCode { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "ERROR_CODE_UNSPECIFIED", + Self::InvalidInput => "ERROR_CODE_INVALID_INPUT", + Self::NoMatchingPrekey => "ERROR_CODE_NO_MATCHING_PREKEY", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for ErrorCode { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ERROR_CODE_UNSPECIFIED", + "ERROR_CODE_INVALID_INPUT", + "ERROR_CODE_NO_MATCHING_PREKEY", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ErrorCode; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(ErrorCode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(ErrorCode::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ERROR_CODE_UNSPECIFIED" => Ok(ErrorCode::Unspecified), + "ERROR_CODE_INVALID_INPUT" => Ok(ErrorCode::InvalidInput), + "ERROR_CODE_NO_MATCHING_PREKEY" => Ok(ErrorCode::NoMatchingPrekey), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for KeystoreError { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.message.is_empty() { + len += 1; + } + if self.code != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.KeystoreError", len)?; + if !self.message.is_empty() { + struct_ser.serialize_field("message", &self.message)?; + } + if self.code != 0 { + let v = ErrorCode::from_i32(self.code) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.code)))?; + struct_ser.serialize_field("code", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for KeystoreError { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "message", + "code", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Message, + Code, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "message" => Ok(GeneratedField::Message), + "code" => Ok(GeneratedField::Code), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = KeystoreError; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.KeystoreError") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut message__ = None; + let mut code__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = Some(map.next_value()?); + } + GeneratedField::Code => { + if code__.is_some() { + return Err(serde::de::Error::duplicate_field("code")); + } + code__ = Some(map.next_value::()? as i32); + } + } + } + Ok(KeystoreError { + message: message__.unwrap_or_default(), + code: code__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.KeystoreError", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SaveInvitesRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SaveInvitesRequest", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SaveInvitesRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SaveInvitesRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SaveInvitesRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(SaveInvitesRequest { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SaveInvitesRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for save_invites_request::Request { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.content_topic.is_empty() { + len += 1; + } + if self.timestamp_ns != 0 { + len += 1; + } + if !self.payload.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SaveInvitesRequest.Request", len)?; + if !self.content_topic.is_empty() { + struct_ser.serialize_field("contentTopic", &self.content_topic)?; + } + if self.timestamp_ns != 0 { + struct_ser.serialize_field("timestampNs", ToString::to_string(&self.timestamp_ns).as_str())?; + } + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for save_invites_request::Request { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "content_topic", + "contentTopic", + "timestamp_ns", + "timestampNs", + "payload", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ContentTopic, + TimestampNs, + Payload, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "contentTopic" | "content_topic" => Ok(GeneratedField::ContentTopic), + "timestampNs" | "timestamp_ns" => Ok(GeneratedField::TimestampNs), + "payload" => Ok(GeneratedField::Payload), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = save_invites_request::Request; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SaveInvitesRequest.Request") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut content_topic__ = None; + let mut timestamp_ns__ = None; + let mut payload__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ContentTopic => { + if content_topic__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopic")); + } + content_topic__ = Some(map.next_value()?); + } + GeneratedField::TimestampNs => { + if timestamp_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampNs")); + } + timestamp_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(save_invites_request::Request { + content_topic: content_topic__.unwrap_or_default(), + timestamp_ns: timestamp_ns__.unwrap_or_default(), + payload: payload__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SaveInvitesRequest.Request", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SaveInvitesResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.responses.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse", len)?; + if !self.responses.is_empty() { + struct_ser.serialize_field("responses", &self.responses)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SaveInvitesResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "responses", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Responses, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "responses" => Ok(GeneratedField::Responses), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SaveInvitesResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SaveInvitesResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut responses__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Responses => { + if responses__.is_some() { + return Err(serde::de::Error::duplicate_field("responses")); + } + responses__ = Some(map.next_value()?); + } + } + } + Ok(SaveInvitesResponse { + responses: responses__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for save_invites_response::Response { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.response.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse.Response", len)?; + if let Some(v) = self.response.as_ref() { + match v { + save_invites_response::response::Response::Result(v) => { + struct_ser.serialize_field("result", v)?; + } + save_invites_response::response::Response::Error(v) => { + struct_ser.serialize_field("error", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for save_invites_response::Response { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "result", + "error", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Result, + Error, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "result" => Ok(GeneratedField::Result), + "error" => Ok(GeneratedField::Error), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = save_invites_response::Response; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SaveInvitesResponse.Response") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut response__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Result => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("result")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(save_invites_response::response::Response::Result) +; + } + GeneratedField::Error => { + if response__.is_some() { + return Err(serde::de::Error::duplicate_field("error")); + } + response__ = map.next_value::<::std::option::Option<_>>()?.map(save_invites_response::response::Response::Error) +; + } + } + } + Ok(save_invites_response::Response { + response: response__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse.Response", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for save_invites_response::response::Success { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.conversation.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse.Response.Success", len)?; + if let Some(v) = self.conversation.as_ref() { + struct_ser.serialize_field("conversation", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for save_invites_response::response::Success { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "conversation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Conversation, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "conversation" => Ok(GeneratedField::Conversation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = save_invites_response::response::Success; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SaveInvitesResponse.Response.Success") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut conversation__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Conversation => { + if conversation__.is_some() { + return Err(serde::de::Error::duplicate_field("conversation")); + } + conversation__ = map.next_value()?; + } + } + } + Ok(save_invites_response::response::Success { + conversation: conversation__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SaveInvitesResponse.Response.Success", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignDigestRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.digest.is_empty() { + len += 1; + } + if self.signer.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.SignDigestRequest", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", pbjson::private::base64::encode(&self.digest).as_str())?; + } + if let Some(v) = self.signer.as_ref() { + match v { + sign_digest_request::Signer::IdentityKey(v) => { + struct_ser.serialize_field("identityKey", v)?; + } + sign_digest_request::Signer::PrekeyIndex(v) => { + struct_ser.serialize_field("prekeyIndex", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignDigestRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "digest", + "identity_key", + "identityKey", + "prekey_index", + "prekeyIndex", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Digest, + IdentityKey, + PrekeyIndex, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "digest" => Ok(GeneratedField::Digest), + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "prekeyIndex" | "prekey_index" => Ok(GeneratedField::PrekeyIndex), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignDigestRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.SignDigestRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut digest__ = None; + let mut signer__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); + } + digest__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::IdentityKey => { + if signer__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + signer__ = map.next_value::<::std::option::Option<_>>()?.map(sign_digest_request::Signer::IdentityKey); + } + GeneratedField::PrekeyIndex => { + if signer__.is_some() { + return Err(serde::de::Error::duplicate_field("prekeyIndex")); + } + signer__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| sign_digest_request::Signer::PrekeyIndex(x.0)); + } + } + } + Ok(SignDigestRequest { + digest: digest__.unwrap_or_default(), + signer: signer__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.SignDigestRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for TopicMap { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.topics.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.TopicMap", len)?; + if !self.topics.is_empty() { + struct_ser.serialize_field("topics", &self.topics)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for TopicMap { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "topics", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Topics, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "topics" => Ok(GeneratedField::Topics), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = TopicMap; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.TopicMap") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut topics__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Topics => { + if topics__.is_some() { + return Err(serde::de::Error::duplicate_field("topics")); + } + topics__ = Some( + map.next_value::>()? + ); + } + } + } + Ok(TopicMap { + topics: topics__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.TopicMap", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for topic_map::TopicData { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_ns != 0 { + len += 1; + } + if !self.peer_address.is_empty() { + len += 1; + } + if self.invitation.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.keystore_api.v1.TopicMap.TopicData", len)?; + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + if !self.peer_address.is_empty() { + struct_ser.serialize_field("peerAddress", &self.peer_address)?; + } + if let Some(v) = self.invitation.as_ref() { + struct_ser.serialize_field("invitation", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for topic_map::TopicData { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_ns", + "createdNs", + "peer_address", + "peerAddress", + "invitation", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedNs, + PeerAddress, + Invitation, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + "peerAddress" | "peer_address" => Ok(GeneratedField::PeerAddress), + "invitation" => Ok(GeneratedField::Invitation), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = topic_map::TopicData; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.keystore_api.v1.TopicMap.TopicData") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_ns__ = None; + let mut peer_address__ = None; + let mut invitation__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PeerAddress => { + if peer_address__.is_some() { + return Err(serde::de::Error::duplicate_field("peerAddress")); + } + peer_address__ = Some(map.next_value()?); + } + GeneratedField::Invitation => { + if invitation__.is_some() { + return Err(serde::de::Error::duplicate_field("invitation")); + } + invitation__ = map.next_value()?; + } + } + } + Ok(topic_map::TopicData { + created_ns: created_ns__.unwrap_or_default(), + peer_address: peer_address__.unwrap_or_default(), + invitation: invitation__, + }) + } + } + deserializer.deserialize_struct("xmtp.keystore_api.v1.TopicMap.TopicData", FIELDS, GeneratedVisitor) + } +} diff --git a/crates/xmtp-proto/src/gen/xmtp.message_api.v1.rs b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.rs new file mode 100644 index 000000000..00ea86b5a --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.rs @@ -0,0 +1,639 @@ +// @generated +/// Token is used by clients to prove to the nodes +/// that they are serving a specific wallet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Token { + /// identity key signed by a wallet + #[prost(message, optional, tag="1")] + pub identity_key: ::core::option::Option, + /// encoded bytes of AuthData + #[prost(bytes="vec", tag="2")] + pub auth_data_bytes: ::prost::alloc::vec::Vec, + /// identity key signature of AuthData bytes + #[prost(message, optional, tag="3")] + pub auth_data_signature: ::core::option::Option, +} +/// AuthData carries token parameters that are authenticated +/// by the identity key signature. +/// It is embedded in the Token structure as bytes +/// so that the bytes don't need to be reconstructed +/// to verify the token signature. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AuthData { + /// address of the wallet + #[prost(string, tag="1")] + pub wallet_addr: ::prost::alloc::string::String, + /// time when the token was generated/signed + #[prost(uint64, tag="2")] + pub created_ns: u64, +} +/// This is based off of the go-waku Index type, but with the +/// receiverTime and pubsubTopic removed for simplicity. +/// Both removed fields are optional +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct IndexCursor { + #[prost(bytes="vec", tag="1")] + pub digest: ::prost::alloc::vec::Vec, + #[prost(uint64, tag="2")] + pub sender_time_ns: u64, +} +/// Wrapper for potentially multiple types of cursor +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Cursor { + /// Making the cursor a one-of type, as I would like to change the way we + /// handle pagination to use a precomputed sort field. + /// This way we can handle both methods + #[prost(oneof="cursor::Cursor", tags="1")] + pub cursor: ::core::option::Option, +} +/// Nested message and enum types in `Cursor`. +pub mod cursor { + /// Making the cursor a one-of type, as I would like to change the way we + /// handle pagination to use a precomputed sort field. + /// This way we can handle both methods + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Cursor { + #[prost(message, tag="1")] + Index(super::IndexCursor), + } +} +/// This is based off of the go-waku PagingInfo struct, but with the direction +/// changed to our SortDirection enum format +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PagingInfo { + /// Note: this is a uint32, while go-waku's pageSize is a uint64 + #[prost(uint32, tag="1")] + pub limit: u32, + #[prost(message, optional, tag="2")] + pub cursor: ::core::option::Option, + #[prost(enumeration="SortDirection", tag="3")] + pub direction: i32, +} +/// Envelope encapsulates a message while in transit. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Envelope { + /// The topic the message belongs to, + /// If the message includes the topic as well + /// it MUST be the same as the topic in the envelope. + #[prost(string, tag="1")] + pub content_topic: ::prost::alloc::string::String, + /// Message creation timestamp + /// If the message includes the timestamp as well + /// it MUST be equivalent to the timestamp in the envelope. + #[prost(uint64, tag="2")] + pub timestamp_ns: u64, + #[prost(bytes="vec", tag="3")] + pub message: ::prost::alloc::vec::Vec, +} +/// Publish +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublishRequest { + #[prost(message, repeated, tag="1")] + pub envelopes: ::prost::alloc::vec::Vec, +} +/// Empty message as a response for Publish +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublishResponse { +} +/// Subscribe +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeRequest { + #[prost(string, repeated, tag="1")] + pub content_topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// SubscribeAll +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SubscribeAllRequest { +} +/// Query +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryRequest { + #[prost(string, repeated, tag="1")] + pub content_topics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + #[prost(uint64, tag="2")] + pub start_time_ns: u64, + #[prost(uint64, tag="3")] + pub end_time_ns: u64, + #[prost(message, optional, tag="4")] + pub paging_info: ::core::option::Option, +} +/// The response, containing envelopes, for a query +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryResponse { + #[prost(message, repeated, tag="1")] + pub envelopes: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub paging_info: ::core::option::Option, +} +/// BatchQuery +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BatchQueryRequest { + #[prost(message, repeated, tag="1")] + pub requests: ::prost::alloc::vec::Vec, +} +/// Response containing a list of QueryResponse messages +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BatchQueryResponse { + #[prost(message, repeated, tag="1")] + pub responses: ::prost::alloc::vec::Vec, +} +/// Sort direction +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum SortDirection { + Unspecified = 0, + Ascending = 1, + Descending = 2, +} +impl SortDirection { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + SortDirection::Unspecified => "SORT_DIRECTION_UNSPECIFIED", + SortDirection::Ascending => "SORT_DIRECTION_ASCENDING", + SortDirection::Descending => "SORT_DIRECTION_DESCENDING", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SORT_DIRECTION_UNSPECIFIED" => Some(Self::Unspecified), + "SORT_DIRECTION_ASCENDING" => Some(Self::Ascending), + "SORT_DIRECTION_DESCENDING" => Some(Self::Descending), + _ => None, + } + } +} +/// Encoded file descriptor set for the `xmtp.message_api.v1` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xee, 0x0b, 0x0a, 0x1a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2f, 0x76, 0x31, 0x2f, 0x61, 0x75, 0x74, 0x68, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x13, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc6, 0x01, 0x0a, 0x05, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x12, 0x43, 0x0a, 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x26, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x68, + 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x12, 0x50, 0x0a, 0x13, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x73, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, + 0x11, 0x61, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x22, 0x4a, 0x0a, 0x08, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x12, 0x1f, + 0x0a, 0x0b, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0a, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x41, 0x64, 0x64, 0x72, 0x12, + 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x42, 0xbb, + 0x01, 0x0a, 0x17, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x41, 0x75, 0x74, 0x68, + 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x12, 0x58, 0x6d, 0x74, + 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, 0xca, + 0x02, 0x12, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, + 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1e, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x4a, 0x9a, 0x07, 0x0a, + 0x06, 0x12, 0x04, 0x01, 0x00, 0x1f, 0x01, 0x0a, 0x2a, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, + 0x12, 0x1a, 0x20, 0x20, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, + 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, + 0x6f, 0x6c, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1c, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x05, 0x00, 0x2a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x41, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x41, 0x0a, 0x66, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x0c, 0x00, 0x13, 0x01, 0x1a, 0x5a, 0x20, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x69, 0x73, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x0a, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x79, + 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x73, + 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x0d, 0x0a, 0x2e, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0e, 0x04, 0x35, 0x1a, 0x21, 0x20, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x61, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x0e, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x24, 0x30, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0e, 0x33, 0x34, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x10, 0x04, 0x1e, 0x1a, 0x1b, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x10, 0x04, 0x09, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x0a, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x1c, 0x1d, 0x0a, 0x37, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x02, 0x12, 0x03, 0x12, 0x04, 0x3c, 0x1a, 0x2a, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x20, 0x6f, 0x66, 0x20, 0x41, 0x75, 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x12, 0x04, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x12, 0x24, 0x37, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x12, 0x3a, 0x3b, 0x0a, 0xe9, 0x01, + 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1a, 0x00, 0x1f, 0x01, 0x1a, 0xdc, 0x01, 0x20, 0x41, 0x75, + 0x74, 0x68, 0x44, 0x61, 0x74, 0x61, 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, + 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, 0x72, 0x65, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x73, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x65, 0x6d, + 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x61, 0x73, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x20, + 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x6e, + 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x65, 0x64, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x76, 0x65, 0x72, + 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x73, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, + 0x12, 0x03, 0x1a, 0x08, 0x10, 0x0a, 0x24, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1c, + 0x04, 0x1b, 0x1a, 0x17, 0x20, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x20, 0x6f, 0x66, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1c, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x1c, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x1c, 0x19, 0x1a, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x1e, + 0x04, 0x1a, 0x1a, 0x2b, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x20, 0x77, 0x61, 0x73, 0x20, 0x67, 0x65, 0x6e, + 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1e, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1e, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1e, 0x18, 0x19, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, 0x0a, 0x9b, 0x2c, 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, + 0x69, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x4b, 0x0a, 0x0b, 0x49, 0x6e, 0x64, + 0x65, 0x78, 0x43, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, + 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, + 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, + 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x22, 0x4c, 0x0a, 0x06, 0x43, 0x75, 0x72, 0x73, 0x6f, 0x72, + 0x12, 0x38, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, + 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x43, 0x75, 0x72, 0x73, 0x6f, + 0x72, 0x48, 0x00, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x42, 0x08, 0x0a, 0x06, 0x63, 0x75, + 0x72, 0x73, 0x6f, 0x72, 0x22, 0x99, 0x01, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x33, 0x0a, 0x06, 0x63, 0x75, 0x72, + 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, + 0x43, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x52, 0x06, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x12, 0x40, + 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x22, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x22, 0x6c, 0x0a, 0x08, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, + 0x63, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6e, + 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x4e, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x4d, + 0x0a, 0x0e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x3b, 0x0a, 0x09, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, + 0x70, 0x65, 0x52, 0x09, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x22, 0x11, 0x0a, + 0x0f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x39, 0x0a, 0x10, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, + 0x74, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x22, 0x15, 0x0a, 0x13, 0x53, + 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0xbb, 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, + 0x6f, 0x70, 0x69, 0x63, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x73, 0x12, 0x22, 0x0a, 0x0d, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x12, 0x1e, + 0x0a, 0x0b, 0x65, 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x6e, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x09, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x4e, 0x73, 0x12, 0x40, + 0x0a, 0x0b, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x67, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, + 0x22, 0x8e, 0x01, 0x0a, 0x0d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x09, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x65, 0x52, 0x09, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x12, + 0x40, 0x0a, 0x0b, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x69, 0x6e, + 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, + 0x6f, 0x22, 0x52, 0x0a, 0x11, 0x42, 0x61, 0x74, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x08, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x73, 0x22, 0x56, 0x0a, 0x12, 0x42, 0x61, 0x74, 0x63, 0x68, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x09, 0x72, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x52, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x2a, 0x6c, 0x0a, + 0x0d, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, + 0x0a, 0x1a, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1c, + 0x0a, 0x18, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, + 0x5f, 0x41, 0x53, 0x43, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x1d, 0x0a, 0x19, + 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x44, + 0x45, 0x53, 0x43, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x32, 0xec, 0x04, 0x0a, 0x0a, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x12, 0x74, 0x0a, 0x07, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x73, 0x68, 0x12, 0x23, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x1e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x18, 0x3a, 0x01, 0x2a, 0x22, 0x13, 0x2f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, + 0x12, 0x75, 0x0a, 0x09, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x12, 0x25, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x76, 0x65, 0x6c, + 0x6f, 0x70, 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x3a, 0x01, 0x2a, 0x22, 0x15, + 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x75, 0x62, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x30, 0x01, 0x12, 0x7f, 0x0a, 0x0c, 0x53, 0x75, 0x62, 0x73, 0x63, + 0x72, 0x69, 0x62, 0x65, 0x41, 0x6c, 0x6c, 0x12, 0x28, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x75, + 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x22, 0x24, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1e, 0x3a, 0x01, 0x2a, 0x22, 0x19, 0x2f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x65, 0x2d, 0x61, 0x6c, 0x6c, 0x30, 0x01, 0x12, 0x6c, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x12, 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x1c, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x16, + 0x3a, 0x01, 0x2a, 0x22, 0x11, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, + 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x81, 0x01, 0x0a, 0x0a, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, 0x70, 0x69, + 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x3a, 0x01, + 0x2a, 0x22, 0x17, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x62, + 0x61, 0x74, 0x63, 0x68, 0x2d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x42, 0xc0, 0x01, 0x0a, 0x17, 0x63, + 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x61, 0x70, 0x69, 0x2e, 0x76, 0x31, 0x42, 0x0f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, + 0x70, 0x69, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2a, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x61, + 0x70, 0x69, 0x2f, 0x76, 0x31, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x12, 0x58, 0x6d, + 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x2e, 0x56, 0x31, + 0xca, 0x02, 0x12, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, + 0x70, 0x69, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1e, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x41, 0x70, 0x69, 0x3a, 0x3a, 0x56, 0x31, 0x4a, 0xc7, 0x1b, + 0x0a, 0x07, 0x12, 0x05, 0x01, 0x00, 0x88, 0x01, 0x01, 0x0a, 0x17, 0x0a, 0x01, 0x0c, 0x12, 0x03, + 0x01, 0x00, 0x12, 0x1a, 0x0d, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x41, 0x50, + 0x49, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x02, 0x00, 0x1c, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x04, 0x00, 0x26, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x06, 0x00, + 0x41, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x06, 0x00, 0x41, 0x0a, 0x11, 0x0a, 0x02, + 0x06, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x2e, 0x01, 0x1a, 0x05, 0x20, 0x52, 0x50, 0x43, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x06, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x12, 0x0a, 0x2f, 0x0a, 0x04, 0x06, + 0x00, 0x02, 0x00, 0x12, 0x04, 0x0c, 0x04, 0x11, 0x05, 0x1a, 0x21, 0x20, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x73, 0x68, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x6f, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x00, 0x02, 0x12, 0x03, 0x0c, 0x11, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x0c, 0x2a, 0x39, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x04, 0x12, + 0x04, 0x0d, 0x08, 0x10, 0x06, 0x0a, 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x00, 0x04, 0xb0, 0xca, + 0xbc, 0x22, 0x12, 0x04, 0x0d, 0x08, 0x10, 0x06, 0x0a, 0x4b, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, + 0x12, 0x04, 0x13, 0x04, 0x18, 0x05, 0x1a, 0x3d, 0x20, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, + 0x62, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x6f, + 0x66, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x73, 0x20, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x70, 0x72, 0x65, 0x64, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x13, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x13, 0x13, + 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x13, 0x2e, 0x34, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x13, 0x35, 0x3d, 0x0a, 0x0d, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x01, 0x04, 0x12, 0x04, 0x14, 0x08, 0x17, 0x06, 0x0a, 0x11, 0x0a, 0x09, + 0x06, 0x00, 0x02, 0x01, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x14, 0x08, 0x17, 0x06, 0x0a, + 0x35, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x02, 0x12, 0x04, 0x1a, 0x04, 0x1f, 0x05, 0x1a, 0x27, 0x20, + 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x20, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x1a, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x1a, + 0x16, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x1a, 0x34, 0x3a, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1a, 0x3b, 0x43, 0x0a, 0x0d, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x02, 0x04, 0x12, 0x04, 0x1b, 0x08, 0x1e, 0x0a, 0x0a, 0x11, 0x0a, + 0x09, 0x06, 0x00, 0x02, 0x02, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x1b, 0x08, 0x1e, 0x0a, + 0x0a, 0x2c, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x03, 0x12, 0x04, 0x21, 0x04, 0x26, 0x05, 0x1a, 0x1e, + 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x21, 0x08, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x03, 0x02, 0x12, 0x03, 0x21, 0x0f, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x03, 0x03, 0x12, 0x03, 0x21, 0x26, 0x33, 0x0a, 0x0d, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x03, + 0x04, 0x12, 0x04, 0x22, 0x08, 0x25, 0x06, 0x0a, 0x11, 0x0a, 0x09, 0x06, 0x00, 0x02, 0x03, 0x04, + 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x22, 0x08, 0x25, 0x06, 0x0a, 0x46, 0x0a, 0x04, 0x06, 0x00, + 0x02, 0x04, 0x12, 0x04, 0x28, 0x04, 0x2d, 0x05, 0x1a, 0x38, 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, + 0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x71, 0x75, 0x65, 0x72, 0x69, 0x65, + 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, + 0x64, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x28, 0x08, 0x12, + 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x02, 0x12, 0x03, 0x28, 0x14, 0x25, 0x0a, 0x0c, + 0x0a, 0x05, 0x06, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x28, 0x30, 0x42, 0x0a, 0x0d, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x04, 0x04, 0x12, 0x04, 0x29, 0x08, 0x2c, 0x06, 0x0a, 0x11, 0x0a, 0x09, 0x06, + 0x00, 0x02, 0x04, 0x04, 0xb0, 0xca, 0xbc, 0x22, 0x12, 0x04, 0x29, 0x08, 0x2c, 0x06, 0x0a, 0x1c, + 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x31, 0x00, 0x35, 0x01, 0x1a, 0x10, 0x20, 0x53, 0x6f, 0x72, + 0x74, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x05, 0x00, 0x01, 0x12, 0x03, 0x31, 0x05, 0x12, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x32, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x32, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x32, 0x21, + 0x22, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x33, 0x04, 0x21, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x33, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, + 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x33, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, + 0x02, 0x02, 0x12, 0x03, 0x34, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x34, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, + 0x34, 0x20, 0x21, 0x0a, 0xa0, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x3a, 0x00, 0x3d, 0x01, + 0x1a, 0x93, 0x01, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, + 0x64, 0x20, 0x6f, 0x66, 0x66, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x6f, 0x2d, + 0x77, 0x61, 0x6b, 0x75, 0x20, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, + 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x20, 0x72, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x72, 0x65, 0x6d, 0x6f, + 0x76, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x69, + 0x74, 0x79, 0x2e, 0x0a, 0x20, 0x42, 0x6f, 0x74, 0x68, 0x20, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x6f, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x3a, + 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x3b, 0x04, 0x15, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3b, 0x04, 0x09, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3b, 0x0a, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3b, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x3c, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x3c, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3c, + 0x0b, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3c, 0x1c, 0x1d, + 0x0a, 0x3e, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x40, 0x00, 0x47, 0x01, 0x1a, 0x32, 0x20, 0x57, + 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x6f, 0x74, 0x65, 0x6e, + 0x74, 0x69, 0x61, 0x6c, 0x6c, 0x79, 0x20, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x20, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x40, 0x08, 0x0e, 0x0a, 0xaf, 0x01, 0x0a, + 0x04, 0x04, 0x01, 0x08, 0x00, 0x12, 0x04, 0x44, 0x04, 0x46, 0x05, 0x1a, 0xa0, 0x01, 0x20, 0x4d, + 0x61, 0x6b, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x75, 0x72, 0x73, 0x6f, 0x72, + 0x20, 0x61, 0x20, 0x6f, 0x6e, 0x65, 0x2d, 0x6f, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20, + 0x61, 0x73, 0x20, 0x49, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, + 0x74, 0x6f, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, + 0x79, 0x20, 0x77, 0x65, 0x0a, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x20, 0x61, + 0x20, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x20, 0x73, 0x6f, 0x72, + 0x74, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x77, + 0x61, 0x79, 0x20, 0x77, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x73, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x08, 0x00, 0x01, 0x12, 0x03, 0x44, 0x0a, 0x10, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x45, 0x08, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x45, 0x08, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x45, 0x14, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x45, 0x1c, 0x1d, 0x0a, 0x82, 0x01, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x4b, 0x00, 0x50, 0x01, + 0x1a, 0x76, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x62, 0x61, 0x73, 0x65, 0x64, + 0x20, 0x6f, 0x66, 0x66, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x6f, 0x2d, 0x77, + 0x61, 0x6b, 0x75, 0x20, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x66, 0x6f, 0x20, 0x73, + 0x74, 0x72, 0x75, 0x63, 0x74, 0x2c, 0x20, 0x62, 0x75, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x63, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6f, 0x75, 0x72, 0x20, 0x53, 0x6f, + 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x75, 0x6d, + 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x4b, 0x08, 0x12, 0x0a, 0x4b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x4d, 0x04, + 0x15, 0x1a, 0x3e, 0x20, 0x4e, 0x6f, 0x74, 0x65, 0x3a, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, + 0x73, 0x20, 0x61, 0x20, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x2c, 0x20, 0x77, 0x68, 0x69, 0x6c, + 0x65, 0x20, 0x67, 0x6f, 0x2d, 0x77, 0x61, 0x6b, 0x75, 0x27, 0x73, 0x20, 0x70, 0x61, 0x67, 0x65, + 0x53, 0x69, 0x7a, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x4d, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4d, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x4d, 0x13, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x4e, 0x04, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x4e, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x4e, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4e, + 0x14, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x4f, 0x04, 0x20, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x4f, 0x04, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x4f, 0x12, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x03, 0x12, 0x03, 0x4f, 0x1e, 0x1f, 0x0a, 0x3f, 0x0a, 0x02, 0x04, 0x03, 0x12, + 0x04, 0x53, 0x00, 0x5d, 0x01, 0x1a, 0x33, 0x20, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x61, 0x20, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x68, 0x69, 0x6c, 0x65, 0x20, 0x69, 0x6e, + 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, + 0x01, 0x12, 0x03, 0x53, 0x08, 0x10, 0x0a, 0x8f, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, + 0x03, 0x57, 0x04, 0x1d, 0x1a, 0x81, 0x01, 0x20, 0x54, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x69, + 0x63, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x62, 0x65, + 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x2c, 0x0a, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x61, 0x73, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x0a, 0x20, 0x69, 0x74, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, + 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x57, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x57, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x57, + 0x1b, 0x1c, 0x0a, 0x92, 0x01, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x5b, 0x04, 0x1c, + 0x1a, 0x84, 0x01, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x0a, 0x20, + 0x49, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x6c, 0x6c, 0x0a, 0x20, 0x69, + 0x74, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x65, 0x71, 0x75, 0x69, 0x76, 0x61, + 0x6c, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x76, + 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x5b, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x5b, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x5b, 0x1a, + 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x5c, 0x04, 0x16, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x05, 0x12, 0x03, 0x5c, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x01, 0x12, 0x03, 0x5c, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x5c, 0x14, 0x15, 0x0a, 0x15, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, + 0x60, 0x00, 0x62, 0x01, 0x1a, 0x09, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x60, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x61, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x61, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x61, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, 0x03, 0x61, + 0x16, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x61, 0x22, 0x23, + 0x0a, 0x35, 0x0a, 0x02, 0x04, 0x05, 0x12, 0x04, 0x65, 0x00, 0x66, 0x01, 0x1a, 0x29, 0x20, 0x45, + 0x6d, 0x70, 0x74, 0x79, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x61, 0x73, 0x20, + 0x61, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x50, + 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, + 0x65, 0x08, 0x17, 0x0a, 0x17, 0x0a, 0x02, 0x04, 0x06, 0x12, 0x04, 0x69, 0x00, 0x6b, 0x01, 0x1a, + 0x0b, 0x20, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x06, 0x01, 0x12, 0x03, 0x69, 0x08, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, 0x00, + 0x12, 0x03, 0x6a, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x04, 0x12, 0x03, + 0x6a, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x05, 0x12, 0x03, 0x6a, 0x0d, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x6a, 0x14, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x6a, 0x25, 0x26, 0x0a, 0x1a, 0x0a, + 0x02, 0x04, 0x07, 0x12, 0x04, 0x6e, 0x00, 0x6f, 0x01, 0x1a, 0x0e, 0x20, 0x53, 0x75, 0x62, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x41, 0x6c, 0x6c, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x07, 0x01, + 0x12, 0x03, 0x6e, 0x08, 0x1b, 0x0a, 0x13, 0x0a, 0x02, 0x04, 0x08, 0x12, 0x04, 0x73, 0x00, 0x78, + 0x01, 0x1a, 0x07, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x08, + 0x01, 0x12, 0x03, 0x73, 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x00, 0x12, 0x03, + 0x74, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x04, 0x12, 0x03, 0x74, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x05, 0x12, 0x03, 0x74, 0x0d, 0x13, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x00, 0x01, 0x12, 0x03, 0x74, 0x14, 0x22, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x00, 0x03, 0x12, 0x03, 0x74, 0x25, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x08, 0x02, 0x01, 0x12, 0x03, 0x75, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x75, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x75, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x01, 0x03, 0x12, 0x03, 0x75, + 0x1b, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, 0x02, 0x12, 0x03, 0x76, 0x04, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x02, 0x05, 0x12, 0x03, 0x76, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x08, 0x02, 0x02, 0x01, 0x12, 0x03, 0x76, 0x0b, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x08, 0x02, 0x02, 0x03, 0x12, 0x03, 0x76, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x08, 0x02, + 0x03, 0x12, 0x03, 0x77, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x06, 0x12, + 0x03, 0x77, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x01, 0x12, 0x03, 0x77, + 0x0f, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x08, 0x02, 0x03, 0x03, 0x12, 0x03, 0x77, 0x1d, 0x1e, + 0x0a, 0x3d, 0x0a, 0x02, 0x04, 0x09, 0x12, 0x04, 0x7b, 0x00, 0x7e, 0x01, 0x1a, 0x31, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2c, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x65, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, + 0x73, 0x2c, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x09, 0x01, 0x12, 0x03, 0x7b, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x09, 0x02, 0x00, 0x12, 0x03, 0x7c, 0x04, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, + 0x04, 0x12, 0x03, 0x7c, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x7c, 0x0d, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x01, 0x12, 0x03, 0x7c, + 0x16, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, 0x00, 0x03, 0x12, 0x03, 0x7c, 0x22, 0x23, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x09, 0x02, 0x01, 0x12, 0x03, 0x7d, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x09, 0x02, 0x01, 0x06, 0x12, 0x03, 0x7d, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x09, 0x02, 0x01, 0x01, 0x12, 0x03, 0x7d, 0x0f, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x09, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x7d, 0x1d, 0x1e, 0x0a, 0x1a, 0x0a, 0x02, 0x04, 0x0a, 0x12, 0x06, 0x81, + 0x01, 0x00, 0x83, 0x01, 0x01, 0x1a, 0x0c, 0x20, 0x42, 0x61, 0x74, 0x63, 0x68, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x0a, 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0a, 0x01, 0x12, 0x04, 0x81, 0x01, 0x08, 0x19, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x0a, 0x02, 0x00, 0x12, 0x04, 0x82, 0x01, 0x04, 0x27, 0x0a, 0x0d, + 0x0a, 0x05, 0x04, 0x0a, 0x02, 0x00, 0x04, 0x12, 0x04, 0x82, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, + 0x05, 0x04, 0x0a, 0x02, 0x00, 0x06, 0x12, 0x04, 0x82, 0x01, 0x0d, 0x19, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x0a, 0x02, 0x00, 0x01, 0x12, 0x04, 0x82, 0x01, 0x1a, 0x22, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0a, 0x02, 0x00, 0x03, 0x12, 0x04, 0x82, 0x01, 0x25, 0x26, 0x0a, 0x44, 0x0a, 0x02, 0x04, 0x0b, + 0x12, 0x06, 0x86, 0x01, 0x00, 0x88, 0x01, 0x01, 0x1a, 0x36, 0x20, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, + 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x0a, + 0x0a, 0x0b, 0x0a, 0x03, 0x04, 0x0b, 0x01, 0x12, 0x04, 0x86, 0x01, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x0b, 0x02, 0x00, 0x12, 0x04, 0x87, 0x01, 0x04, 0x29, 0x0a, 0x0d, 0x0a, 0x05, 0x04, + 0x0b, 0x02, 0x00, 0x04, 0x12, 0x04, 0x87, 0x01, 0x04, 0x0c, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, + 0x02, 0x00, 0x06, 0x12, 0x04, 0x87, 0x01, 0x0d, 0x1a, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, + 0x00, 0x01, 0x12, 0x04, 0x87, 0x01, 0x1b, 0x24, 0x0a, 0x0d, 0x0a, 0x05, 0x04, 0x0b, 0x02, 0x00, + 0x03, 0x12, 0x04, 0x87, 0x01, 0x27, 0x28, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("xmtp.message_api.v1.serde.rs"); +include!("xmtp.message_api.v1.tonic.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/crates/xmtp-proto/src/gen/xmtp.message_api.v1.serde.rs b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.serde.rs new file mode 100644 index 000000000..b928320ec --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.serde.rs @@ -0,0 +1,1554 @@ +// @generated +impl serde::Serialize for AuthData { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.wallet_addr.is_empty() { + len += 1; + } + if self.created_ns != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.AuthData", len)?; + if !self.wallet_addr.is_empty() { + struct_ser.serialize_field("walletAddr", &self.wallet_addr)?; + } + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for AuthData { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "wallet_addr", + "walletAddr", + "created_ns", + "createdNs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WalletAddr, + CreatedNs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "walletAddr" | "wallet_addr" => Ok(GeneratedField::WalletAddr), + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = AuthData; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.AuthData") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut wallet_addr__ = None; + let mut created_ns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WalletAddr => { + if wallet_addr__.is_some() { + return Err(serde::de::Error::duplicate_field("walletAddr")); + } + wallet_addr__ = Some(map.next_value()?); + } + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(AuthData { + wallet_addr: wallet_addr__.unwrap_or_default(), + created_ns: created_ns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.AuthData", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BatchQueryRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.requests.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.BatchQueryRequest", len)?; + if !self.requests.is_empty() { + struct_ser.serialize_field("requests", &self.requests)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BatchQueryRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "requests", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Requests, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "requests" => Ok(GeneratedField::Requests), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BatchQueryRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.BatchQueryRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut requests__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Requests => { + if requests__.is_some() { + return Err(serde::de::Error::duplicate_field("requests")); + } + requests__ = Some(map.next_value()?); + } + } + } + Ok(BatchQueryRequest { + requests: requests__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.BatchQueryRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for BatchQueryResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.responses.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.BatchQueryResponse", len)?; + if !self.responses.is_empty() { + struct_ser.serialize_field("responses", &self.responses)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for BatchQueryResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "responses", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Responses, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "responses" => Ok(GeneratedField::Responses), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = BatchQueryResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.BatchQueryResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut responses__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Responses => { + if responses__.is_some() { + return Err(serde::de::Error::duplicate_field("responses")); + } + responses__ = Some(map.next_value()?); + } + } + } + Ok(BatchQueryResponse { + responses: responses__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.BatchQueryResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Cursor { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.cursor.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.Cursor", len)?; + if let Some(v) = self.cursor.as_ref() { + match v { + cursor::Cursor::Index(v) => { + struct_ser.serialize_field("index", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Cursor { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "index", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Index, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "index" => Ok(GeneratedField::Index), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Cursor; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.Cursor") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut cursor__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Index => { + if cursor__.is_some() { + return Err(serde::de::Error::duplicate_field("index")); + } + cursor__ = map.next_value::<::std::option::Option<_>>()?.map(cursor::Cursor::Index) +; + } + } + } + Ok(Cursor { + cursor: cursor__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.Cursor", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Envelope { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.content_topic.is_empty() { + len += 1; + } + if self.timestamp_ns != 0 { + len += 1; + } + if !self.message.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.Envelope", len)?; + if !self.content_topic.is_empty() { + struct_ser.serialize_field("contentTopic", &self.content_topic)?; + } + if self.timestamp_ns != 0 { + struct_ser.serialize_field("timestampNs", ToString::to_string(&self.timestamp_ns).as_str())?; + } + if !self.message.is_empty() { + struct_ser.serialize_field("message", pbjson::private::base64::encode(&self.message).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Envelope { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "content_topic", + "contentTopic", + "timestamp_ns", + "timestampNs", + "message", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ContentTopic, + TimestampNs, + Message, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "contentTopic" | "content_topic" => Ok(GeneratedField::ContentTopic), + "timestampNs" | "timestamp_ns" => Ok(GeneratedField::TimestampNs), + "message" => Ok(GeneratedField::Message), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Envelope; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.Envelope") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut content_topic__ = None; + let mut timestamp_ns__ = None; + let mut message__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ContentTopic => { + if content_topic__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopic")); + } + content_topic__ = Some(map.next_value()?); + } + GeneratedField::TimestampNs => { + if timestamp_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("timestampNs")); + } + timestamp_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Message => { + if message__.is_some() { + return Err(serde::de::Error::duplicate_field("message")); + } + message__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(Envelope { + content_topic: content_topic__.unwrap_or_default(), + timestamp_ns: timestamp_ns__.unwrap_or_default(), + message: message__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.Envelope", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for IndexCursor { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.digest.is_empty() { + len += 1; + } + if self.sender_time_ns != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.IndexCursor", len)?; + if !self.digest.is_empty() { + struct_ser.serialize_field("digest", pbjson::private::base64::encode(&self.digest).as_str())?; + } + if self.sender_time_ns != 0 { + struct_ser.serialize_field("senderTimeNs", ToString::to_string(&self.sender_time_ns).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for IndexCursor { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "digest", + "sender_time_ns", + "senderTimeNs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Digest, + SenderTimeNs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "digest" => Ok(GeneratedField::Digest), + "senderTimeNs" | "sender_time_ns" => Ok(GeneratedField::SenderTimeNs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = IndexCursor; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.IndexCursor") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut digest__ = None; + let mut sender_time_ns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Digest => { + if digest__.is_some() { + return Err(serde::de::Error::duplicate_field("digest")); + } + digest__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::SenderTimeNs => { + if sender_time_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("senderTimeNs")); + } + sender_time_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(IndexCursor { + digest: digest__.unwrap_or_default(), + sender_time_ns: sender_time_ns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.IndexCursor", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PagingInfo { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.limit != 0 { + len += 1; + } + if self.cursor.is_some() { + len += 1; + } + if self.direction != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.PagingInfo", len)?; + if self.limit != 0 { + struct_ser.serialize_field("limit", &self.limit)?; + } + if let Some(v) = self.cursor.as_ref() { + struct_ser.serialize_field("cursor", v)?; + } + if self.direction != 0 { + let v = SortDirection::from_i32(self.direction) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.direction)))?; + struct_ser.serialize_field("direction", &v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PagingInfo { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "limit", + "cursor", + "direction", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Limit, + Cursor, + Direction, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "limit" => Ok(GeneratedField::Limit), + "cursor" => Ok(GeneratedField::Cursor), + "direction" => Ok(GeneratedField::Direction), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PagingInfo; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.PagingInfo") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut limit__ = None; + let mut cursor__ = None; + let mut direction__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Limit => { + if limit__.is_some() { + return Err(serde::de::Error::duplicate_field("limit")); + } + limit__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Cursor => { + if cursor__.is_some() { + return Err(serde::de::Error::duplicate_field("cursor")); + } + cursor__ = map.next_value()?; + } + GeneratedField::Direction => { + if direction__.is_some() { + return Err(serde::de::Error::duplicate_field("direction")); + } + direction__ = Some(map.next_value::()? as i32); + } + } + } + Ok(PagingInfo { + limit: limit__.unwrap_or_default(), + cursor: cursor__, + direction: direction__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.PagingInfo", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PublishRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.envelopes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.PublishRequest", len)?; + if !self.envelopes.is_empty() { + struct_ser.serialize_field("envelopes", &self.envelopes)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PublishRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "envelopes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Envelopes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "envelopes" => Ok(GeneratedField::Envelopes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PublishRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.PublishRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut envelopes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Envelopes => { + if envelopes__.is_some() { + return Err(serde::de::Error::duplicate_field("envelopes")); + } + envelopes__ = Some(map.next_value()?); + } + } + } + Ok(PublishRequest { + envelopes: envelopes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.PublishRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PublishResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("xmtp.message_api.v1.PublishResponse", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PublishResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PublishResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.PublishResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(PublishResponse { + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.PublishResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.content_topics.is_empty() { + len += 1; + } + if self.start_time_ns != 0 { + len += 1; + } + if self.end_time_ns != 0 { + len += 1; + } + if self.paging_info.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.QueryRequest", len)?; + if !self.content_topics.is_empty() { + struct_ser.serialize_field("contentTopics", &self.content_topics)?; + } + if self.start_time_ns != 0 { + struct_ser.serialize_field("startTimeNs", ToString::to_string(&self.start_time_ns).as_str())?; + } + if self.end_time_ns != 0 { + struct_ser.serialize_field("endTimeNs", ToString::to_string(&self.end_time_ns).as_str())?; + } + if let Some(v) = self.paging_info.as_ref() { + struct_ser.serialize_field("pagingInfo", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "content_topics", + "contentTopics", + "start_time_ns", + "startTimeNs", + "end_time_ns", + "endTimeNs", + "paging_info", + "pagingInfo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ContentTopics, + StartTimeNs, + EndTimeNs, + PagingInfo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "contentTopics" | "content_topics" => Ok(GeneratedField::ContentTopics), + "startTimeNs" | "start_time_ns" => Ok(GeneratedField::StartTimeNs), + "endTimeNs" | "end_time_ns" => Ok(GeneratedField::EndTimeNs), + "pagingInfo" | "paging_info" => Ok(GeneratedField::PagingInfo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.QueryRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut content_topics__ = None; + let mut start_time_ns__ = None; + let mut end_time_ns__ = None; + let mut paging_info__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ContentTopics => { + if content_topics__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopics")); + } + content_topics__ = Some(map.next_value()?); + } + GeneratedField::StartTimeNs => { + if start_time_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("startTimeNs")); + } + start_time_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::EndTimeNs => { + if end_time_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("endTimeNs")); + } + end_time_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PagingInfo => { + if paging_info__.is_some() { + return Err(serde::de::Error::duplicate_field("pagingInfo")); + } + paging_info__ = map.next_value()?; + } + } + } + Ok(QueryRequest { + content_topics: content_topics__.unwrap_or_default(), + start_time_ns: start_time_ns__.unwrap_or_default(), + end_time_ns: end_time_ns__.unwrap_or_default(), + paging_info: paging_info__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.QueryRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for QueryResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.envelopes.is_empty() { + len += 1; + } + if self.paging_info.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.QueryResponse", len)?; + if !self.envelopes.is_empty() { + struct_ser.serialize_field("envelopes", &self.envelopes)?; + } + if let Some(v) = self.paging_info.as_ref() { + struct_ser.serialize_field("pagingInfo", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for QueryResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "envelopes", + "paging_info", + "pagingInfo", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Envelopes, + PagingInfo, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "envelopes" => Ok(GeneratedField::Envelopes), + "pagingInfo" | "paging_info" => Ok(GeneratedField::PagingInfo), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = QueryResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.QueryResponse") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut envelopes__ = None; + let mut paging_info__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Envelopes => { + if envelopes__.is_some() { + return Err(serde::de::Error::duplicate_field("envelopes")); + } + envelopes__ = Some(map.next_value()?); + } + GeneratedField::PagingInfo => { + if paging_info__.is_some() { + return Err(serde::de::Error::duplicate_field("pagingInfo")); + } + paging_info__ = map.next_value()?; + } + } + } + Ok(QueryResponse { + envelopes: envelopes__.unwrap_or_default(), + paging_info: paging_info__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.QueryResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SortDirection { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Unspecified => "SORT_DIRECTION_UNSPECIFIED", + Self::Ascending => "SORT_DIRECTION_ASCENDING", + Self::Descending => "SORT_DIRECTION_DESCENDING", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for SortDirection { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "SORT_DIRECTION_UNSPECIFIED", + "SORT_DIRECTION_ASCENDING", + "SORT_DIRECTION_DESCENDING", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SortDirection; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(SortDirection::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(SortDirection::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "SORT_DIRECTION_UNSPECIFIED" => Ok(SortDirection::Unspecified), + "SORT_DIRECTION_ASCENDING" => Ok(SortDirection::Ascending), + "SORT_DIRECTION_DESCENDING" => Ok(SortDirection::Descending), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for SubscribeAllRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let len = 0; + let struct_ser = serializer.serialize_struct("xmtp.message_api.v1.SubscribeAllRequest", len)?; + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SubscribeAllRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + Err(serde::de::Error::unknown_field(value, FIELDS)) + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SubscribeAllRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.SubscribeAllRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + while map.next_key::()?.is_some() { + let _ = map.next_value::()?; + } + Ok(SubscribeAllRequest { + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.SubscribeAllRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SubscribeRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.content_topics.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.SubscribeRequest", len)?; + if !self.content_topics.is_empty() { + struct_ser.serialize_field("contentTopics", &self.content_topics)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SubscribeRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "content_topics", + "contentTopics", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ContentTopics, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "contentTopics" | "content_topics" => Ok(GeneratedField::ContentTopics), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SubscribeRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.SubscribeRequest") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut content_topics__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ContentTopics => { + if content_topics__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopics")); + } + content_topics__ = Some(map.next_value()?); + } + } + } + Ok(SubscribeRequest { + content_topics: content_topics__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.SubscribeRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Token { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.identity_key.is_some() { + len += 1; + } + if !self.auth_data_bytes.is_empty() { + len += 1; + } + if self.auth_data_signature.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_api.v1.Token", len)?; + if let Some(v) = self.identity_key.as_ref() { + struct_ser.serialize_field("identityKey", v)?; + } + if !self.auth_data_bytes.is_empty() { + struct_ser.serialize_field("authDataBytes", pbjson::private::base64::encode(&self.auth_data_bytes).as_str())?; + } + if let Some(v) = self.auth_data_signature.as_ref() { + struct_ser.serialize_field("authDataSignature", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Token { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "identity_key", + "identityKey", + "auth_data_bytes", + "authDataBytes", + "auth_data_signature", + "authDataSignature", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IdentityKey, + AuthDataBytes, + AuthDataSignature, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "authDataBytes" | "auth_data_bytes" => Ok(GeneratedField::AuthDataBytes), + "authDataSignature" | "auth_data_signature" => Ok(GeneratedField::AuthDataSignature), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Token; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_api.v1.Token") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut identity_key__ = None; + let mut auth_data_bytes__ = None; + let mut auth_data_signature__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IdentityKey => { + if identity_key__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + identity_key__ = map.next_value()?; + } + GeneratedField::AuthDataBytes => { + if auth_data_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("authDataBytes")); + } + auth_data_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::AuthDataSignature => { + if auth_data_signature__.is_some() { + return Err(serde::de::Error::duplicate_field("authDataSignature")); + } + auth_data_signature__ = map.next_value()?; + } + } + } + Ok(Token { + identity_key: identity_key__, + auth_data_bytes: auth_data_bytes__.unwrap_or_default(), + auth_data_signature: auth_data_signature__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_api.v1.Token", FIELDS, GeneratedVisitor) + } +} diff --git a/crates/xmtp-proto/src/gen/xmtp.message_api.v1.tonic.rs b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.tonic.rs new file mode 100644 index 000000000..56ee8d3a0 --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.message_api.v1.tonic.rs @@ -0,0 +1,173 @@ +// @generated +/// Generated client implementations. +pub mod message_api_client { + #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct MessageApiClient { + inner: tonic::client::Grpc, + } + impl MessageApiClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: std::convert::TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl MessageApiClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + Send + 'static, + ::Error: Into + Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> MessageApiClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + Send + Sync, + { + MessageApiClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + pub async fn publish( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/xmtp.message_api.v1.MessageApi/Publish", + ); + self.inner.unary(request.into_request(), path, codec).await + } + pub async fn subscribe( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/xmtp.message_api.v1.MessageApi/Subscribe", + ); + self.inner.server_streaming(request.into_request(), path, codec).await + } + pub async fn subscribe_all( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/xmtp.message_api.v1.MessageApi/SubscribeAll", + ); + self.inner.server_streaming(request.into_request(), path, codec).await + } + pub async fn query( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/xmtp.message_api.v1.MessageApi/Query", + ); + self.inner.unary(request.into_request(), path, codec).await + } + pub async fn batch_query( + &mut self, + request: impl tonic::IntoRequest, + ) -> Result, tonic::Status> { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/xmtp.message_api.v1.MessageApi/BatchQuery", + ); + self.inner.unary(request.into_request(), path, codec).await + } + } +} diff --git a/crates/xmtp-proto/src/gen/xmtp.message_contents.rs b/crates/xmtp-proto/src/gen/xmtp.message_contents.rs new file mode 100644 index 000000000..99192edfd --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.message_contents.rs @@ -0,0 +1,2295 @@ +// @generated +/// Signature represents a generalized public key signature, +/// defined as a union to support cryptographic algorithm agility. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Signature { + #[prost(oneof="signature::Union", tags="1, 2")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `Signature`. +pub mod signature { + /// ECDSA signature bytes and the recovery bit + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct EcdsaCompact { + /// compact representation [ R || S ], 64 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + /// recovery bit + #[prost(uint32, tag="2")] + pub recovery: u32, + } + /// ECDSA signature bytes and the recovery bit + /// produced by xmtp-js::PublicKey.signWithWallet function, i.e. + /// EIP-191 signature of a "Create Identity" message with the key embedded. + /// Used to sign identity keys. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct WalletEcdsaCompact { + /// compact representation [ R || S ], 64 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + /// recovery bit + #[prost(uint32, tag="2")] + pub recovery: u32, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="1")] + EcdsaCompact(EcdsaCompact), + #[prost(message, tag="2")] + WalletEcdsaCompact(WalletEcdsaCompact), + } +} +/// Ciphertext represents encrypted payload. +/// It is definited as a union to support cryptographic algorithm agility. +/// The payload is accompanied by the cryptographic parameters +/// required by the chosen encryption scheme. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Ciphertext { + #[prost(oneof="ciphertext::Union", tags="1")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `Ciphertext`. +pub mod ciphertext { + // Supported Encryption Schemes + + /// Encryption: AES256-GCM + /// Key derivation function: HKDF-SHA256 + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Aes256gcmHkdfsha256 { + /// 32 bytes + #[prost(bytes="vec", tag="1")] + pub hkdf_salt: ::prost::alloc::vec::Vec, + /// 12 bytes + #[prost(bytes="vec", tag="2")] + pub gcm_nonce: ::prost::alloc::vec::Vec, + /// encrypted payload + #[prost(bytes="vec", tag="3")] + pub payload: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="1")] + Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), + } +} +/// SignedEciesCiphertext represents an ECIES encrypted payload and a signature +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignedEciesCiphertext { + /// serialized Ecies message + #[prost(bytes="vec", tag="1")] + pub ecies_bytes: ::prost::alloc::vec::Vec, + /// signature of sha256(ecies_bytes) signed with the IdentityKey + #[prost(message, optional, tag="2")] + pub signature: ::core::option::Option, +} +/// Nested message and enum types in `SignedEciesCiphertext`. +pub mod signed_ecies_ciphertext { + /// Ecies is ciphertext encrypted using ECIES with a MAC + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Ecies { + /// 65 bytes + #[prost(bytes="vec", tag="1")] + pub ephemeral_public_key: ::prost::alloc::vec::Vec, + /// 16 bytes + #[prost(bytes="vec", tag="2")] + pub iv: ::prost::alloc::vec::Vec, + /// 32 bytes + #[prost(bytes="vec", tag="3")] + pub mac: ::prost::alloc::vec::Vec, + /// encrypted payload with block size of 16 + #[prost(bytes="vec", tag="4")] + pub ciphertext: ::prost::alloc::vec::Vec, + } +} +/// UnsignedPublicKey represents a generalized public key, +/// defined as a union to support cryptographic algorithm agility. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UnsignedPublicKey { + #[prost(uint64, tag="1")] + pub created_ns: u64, + #[prost(oneof="unsigned_public_key::Union", tags="3")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `UnsignedPublicKey`. +pub mod unsigned_public_key { + // Supported key types + + /// EC: SECP256k1 + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Secp256k1Uncompressed { + /// uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="3")] + Secp256k1Uncompressed(Secp256k1Uncompressed), + } +} +/// SignedPublicKey +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignedPublicKey { + /// embeds an UnsignedPublicKey + #[prost(bytes="vec", tag="1")] + pub key_bytes: ::prost::alloc::vec::Vec, + /// signs key_bytes + #[prost(message, optional, tag="2")] + pub signature: ::core::option::Option, +} +/// PublicKeyBundle packages the cryptographic keys associated with a wallet. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignedPublicKeyBundle { + /// Identity key MUST be signed by the wallet. + #[prost(message, optional, tag="1")] + pub identity_key: ::core::option::Option, + /// Pre-key MUST be signed by the identity key. + #[prost(message, optional, tag="2")] + pub pre_key: ::core::option::Option, +} +// LEGACY + +/// PublicKey represents a generalized public key, +/// defined as a union to support cryptographic algorithm agility. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublicKey { + #[prost(uint64, tag="1")] + pub timestamp: u64, + #[prost(message, optional, tag="2")] + pub signature: ::core::option::Option, + #[prost(oneof="public_key::Union", tags="3")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `PublicKey`. +pub mod public_key { + /// The key bytes + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Secp256k1Uncompressed { + /// uncompressed point with prefix (0x04) [ P || X || Y ], 65 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + } + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="3")] + Secp256k1Uncompressed(Secp256k1Uncompressed), + } +} +/// PublicKeyBundle packages the cryptographic keys associated with a wallet, +/// both senders and recipients are identified by their key bundles. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PublicKeyBundle { + /// Identity key MUST be signed by the wallet. + #[prost(message, optional, tag="1")] + pub identity_key: ::core::option::Option, + /// Pre-key MUST be signed by the identity key. + #[prost(message, optional, tag="2")] + pub pre_key: ::core::option::Option, +} +/// Unsealed invitation V1 +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct InvitationV1 { + /// topic name chosen for this conversation. + /// It MUST be randomly generated bytes (length >= 32), + /// then base64 encoded without padding + #[prost(string, tag="1")] + pub topic: ::prost::alloc::string::String, + /// A context object defining metadata + #[prost(message, optional, tag="2")] + pub context: ::core::option::Option, + /// message encryption scheme and keys for this conversation. + #[prost(oneof="invitation_v1::Encryption", tags="3")] + pub encryption: ::core::option::Option, +} +/// Nested message and enum types in `InvitationV1`. +pub mod invitation_v1 { + /// Supported encryption schemes + /// AES256-GCM-HKDF-SHA256 + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Aes256gcmHkdfsha256 { + /// randomly generated key material (32 bytes) + #[prost(bytes="vec", tag="1")] + pub key_material: ::prost::alloc::vec::Vec, + } + /// The context type + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Context { + /// Expected to be a URI (ie xmtp.org/convo1) + #[prost(string, tag="1")] + pub conversation_id: ::prost::alloc::string::String, + /// Key value map of additional metadata that would be exposed to + /// application developers and could be used for filtering + #[prost(map="string, string", tag="2")] + pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + } + /// message encryption scheme and keys for this conversation. + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Encryption { + /// Specify the encryption method to process the key material properly. + #[prost(message, tag="3")] + Aes256GcmHkdfSha256(Aes256gcmHkdfsha256), + } +} +/// Sealed Invitation V1 Header +/// Header carries information that is unencrypted, thus readable by the network +/// it is however authenticated as associated data with the AEAD scheme used +/// to encrypt the invitation body, thus providing tamper evidence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SealedInvitationHeaderV1 { + #[prost(message, optional, tag="1")] + pub sender: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub recipient: ::core::option::Option, + #[prost(uint64, tag="3")] + pub created_ns: u64, +} +/// Sealed Invitation V1 +/// Invitation encrypted with key material derived from the sender's and +/// recipient's public key bundles using simplified X3DH where +/// the sender's ephemeral key is replaced with sender's pre-key. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SealedInvitationV1 { + /// encoded SealedInvitationHeaderV1 used as associated data for Ciphertext + #[prost(bytes="vec", tag="1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted InvitationV1. + #[prost(message, optional, tag="2")] + pub ciphertext: ::core::option::Option, +} +/// Versioned Sealed Invitation +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SealedInvitation { + #[prost(oneof="sealed_invitation::Version", tags="1")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `SealedInvitation`. +pub mod sealed_invitation { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag="1")] + V1(super::SealedInvitationV1), + } +} +/// A light pointer for a conversation that contains no decryption keys +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConversationReference { + #[prost(string, tag="1")] + pub topic: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub peer_address: ::prost::alloc::string::String, + #[prost(uint64, tag="3")] + pub created_ns: u64, + #[prost(message, optional, tag="4")] + pub context: ::core::option::Option, +} +/// ContentTypeId is used to identify the type of content stored in a Message. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContentTypeId { + /// authority governing this content type + #[prost(string, tag="1")] + pub authority_id: ::prost::alloc::string::String, + /// type identifier + #[prost(string, tag="2")] + pub type_id: ::prost::alloc::string::String, + /// major version of the type + #[prost(uint32, tag="3")] + pub version_major: u32, + /// minor version of the type + #[prost(uint32, tag="4")] + pub version_minor: u32, +} +/// EncodedContent bundles the content with metadata identifying its type +/// and parameters required for correct decoding and presentation of the content. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncodedContent { + /// content type identifier used to match the payload with + /// the correct decoding machinery + #[prost(message, optional, tag="1")] + pub r#type: ::core::option::Option, + /// optional encoding parameters required to correctly decode the content + #[prost(map="string, string", tag="2")] + pub parameters: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, + /// optional fallback description of the content that can be used in case + /// the client cannot decode or render the content + #[prost(string, optional, tag="3")] + pub fallback: ::core::option::Option<::prost::alloc::string::String>, + /// optional compression; the value indicates algorithm used to + /// compress the encoded content bytes + #[prost(enumeration="Compression", optional, tag="5")] + pub compression: ::core::option::Option, + /// encoded content itself + #[prost(bytes="vec", tag="4")] + pub content: ::prost::alloc::vec::Vec, +} +/// SignedContent attaches a signature to EncodedContent. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignedContent { + /// MUST contain EncodedContent + #[prost(bytes="vec", tag="1")] + pub payload: ::prost::alloc::vec::Vec, + #[prost(message, optional, tag="2")] + pub sender: ::core::option::Option, + /// MUST be a signature of a concatenation of + /// the message header bytes and the payload bytes, + /// signed by the sender's pre-key. + #[prost(message, optional, tag="3")] + pub signature: ::core::option::Option, +} +/// Recognized compression algorithms +/// protolint:disable ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Compression { + Deflate = 0, + Gzip = 1, +} +impl Compression { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Compression::Deflate => "COMPRESSION_DEFLATE", + Compression::Gzip => "COMPRESSION_GZIP", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "COMPRESSION_DEFLATE" => Some(Self::Deflate), + "COMPRESSION_GZIP" => Some(Self::Gzip), + _ => None, + } + } +} +/// Composite is used to implement xmtp.org/composite content type +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Composite { + #[prost(message, repeated, tag="1")] + pub parts: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `Composite`. +pub mod composite { + /// Part represents one section of a composite message + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Part { + #[prost(oneof="part::Element", tags="1, 2")] + pub element: ::core::option::Option, + } + /// Nested message and enum types in `Part`. + pub mod part { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Element { + #[prost(message, tag="1")] + Part(super::super::EncodedContent), + #[prost(message, tag="2")] + Composite(super::super::Composite), + } + } +} +/// LEGACY: User key bundle V1 using PublicKeys. +/// The PublicKeys MUST be signed. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContactBundleV1 { + #[prost(message, optional, tag="1")] + pub key_bundle: ::core::option::Option, +} +/// User key bundle V2 using SignedPublicKeys. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContactBundleV2 { + #[prost(message, optional, tag="1")] + pub key_bundle: ::core::option::Option, +} +/// Versioned ContactBundle +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ContactBundle { + #[prost(oneof="contact_bundle::Version", tags="1, 2")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `ContactBundle`. +pub mod contact_bundle { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag="1")] + V1(super::ContactBundleV1), + #[prost(message, tag="2")] + V2(super::ContactBundleV2), + } +} +// Message V1 + +/// Message header is encoded separately as the bytes are also used +/// as associated data for authenticated encryption +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MessageHeaderV1 { + #[prost(message, optional, tag="1")] + pub sender: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub recipient: ::core::option::Option, + #[prost(uint64, tag="3")] + pub timestamp: u64, +} +/// Message is the top level protocol element +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MessageV1 { + /// encapsulates encoded MessageHeaderV1 + #[prost(bytes="vec", tag="1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted EncodedContent + #[prost(message, optional, tag="2")] + pub ciphertext: ::core::option::Option, +} +// Message V2 + +/// Message header carries information that is not encrypted, and is therefore +/// observable by the network. It is however authenticated as associated data +/// of the AEAD encryption used to protect the message, +/// thus providing tamper evidence. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MessageHeaderV2 { + /// sender specified message creation time + #[prost(uint64, tag="1")] + pub created_ns: u64, + /// the topic the message belongs to + #[prost(string, tag="2")] + pub topic: ::prost::alloc::string::String, +} +/// Message combines the encoded header with the encrypted payload. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MessageV2 { + /// encapsulates encoded MessageHeaderV2 + #[prost(bytes="vec", tag="1")] + pub header_bytes: ::prost::alloc::vec::Vec, + /// Ciphertext.payload MUST contain encrypted SignedContent + #[prost(message, optional, tag="2")] + pub ciphertext: ::core::option::Option, +} +/// Versioned Message +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Message { + #[prost(oneof="message::Version", tags="1, 2")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `Message`. +pub mod message { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag="1")] + V1(super::MessageV1), + #[prost(message, tag="2")] + V2(super::MessageV2), + } +} +/// DecodedMessage represents the decrypted message contents. +/// DecodedMessage instances are not stored on the network, but +/// may be serialized and stored by clients +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct DecodedMessage { + #[prost(string, tag="1")] + pub id: ::prost::alloc::string::String, + #[prost(string, tag="2")] + pub message_version: ::prost::alloc::string::String, + #[prost(string, tag="3")] + pub sender_address: ::prost::alloc::string::String, + #[prost(string, optional, tag="4")] + pub recipient_address: ::core::option::Option<::prost::alloc::string::String>, + #[prost(uint64, tag="5")] + pub sent_ns: u64, + #[prost(string, tag="6")] + pub content_topic: ::prost::alloc::string::String, + #[prost(message, optional, tag="7")] + pub conversation: ::core::option::Option, + /// encapsulates EncodedContent + #[prost(bytes="vec", tag="8")] + pub content_bytes: ::prost::alloc::vec::Vec, +} +/// PrivateKey generalized to support different key types +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SignedPrivateKey { + /// time the key was created + #[prost(uint64, tag="1")] + pub created_ns: u64, + /// public key for this private key + #[prost(message, optional, tag="3")] + pub public_key: ::core::option::Option, + /// private key + #[prost(oneof="signed_private_key::Union", tags="2")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `SignedPrivateKey`. +pub mod signed_private_key { + // Supported key types + + /// EC: SECP256k1 + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Secp256k1 { + /// D big-endian, 32 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + } + /// private key + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="2")] + Secp256k1(Secp256k1), + } +} +/// PrivateKeyBundle wraps the identityKey and the preKeys, +/// enforces usage of signed keys. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PrivateKeyBundleV2 { + #[prost(message, optional, tag="1")] + pub identity_key: ::core::option::Option, + /// all the known pre-keys, newer keys first, + #[prost(message, repeated, tag="2")] + pub pre_keys: ::prost::alloc::vec::Vec, +} +/// LEGACY: PrivateKey generalized to support different key types +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PrivateKey { + /// time the key was created + #[prost(uint64, tag="1")] + pub timestamp: u64, + /// public key for this private key + #[prost(message, optional, tag="3")] + pub public_key: ::core::option::Option, + /// private key + #[prost(oneof="private_key::Union", tags="2")] + pub union: ::core::option::Option, +} +/// Nested message and enum types in `PrivateKey`. +pub mod private_key { + // Supported key types + + /// EC: SECP256k1 + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] + pub struct Secp256k1 { + /// D big-endian, 32 bytes + #[prost(bytes="vec", tag="1")] + pub bytes: ::prost::alloc::vec::Vec, + } + /// private key + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Union { + #[prost(message, tag="2")] + Secp256k1(Secp256k1), + } +} +/// LEGACY: PrivateKeyBundleV1 wraps the identityKey and the preKeys +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PrivateKeyBundleV1 { + #[prost(message, optional, tag="1")] + pub identity_key: ::core::option::Option, + /// all the known pre-keys, newer keys first, + #[prost(message, repeated, tag="2")] + pub pre_keys: ::prost::alloc::vec::Vec, +} +/// Versioned PrivateKeyBundle +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PrivateKeyBundle { + #[prost(oneof="private_key_bundle::Version", tags="1, 2")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `PrivateKeyBundle`. +pub mod private_key_bundle { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag="1")] + V1(super::PrivateKeyBundleV1), + #[prost(message, tag="2")] + V2(super::PrivateKeyBundleV2), + } +} +/// PrivateKeyBundle encrypted with key material generated by +/// signing a randomly generated "pre-key" with the user's wallet, +/// i.e. EIP-191 signature of a "storage signature" message with +/// the pre-key embedded in it. +/// (see xmtp-js::PrivateKeyBundle.toEncryptedBytes for details) +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptedPrivateKeyBundleV1 { + /// randomly generated pre-key + /// + /// 32 bytes + #[prost(bytes="vec", tag="1")] + pub wallet_pre_key: ::prost::alloc::vec::Vec, + /// MUST contain encrypted PrivateKeyBundle + #[prost(message, optional, tag="2")] + pub ciphertext: ::core::option::Option, +} +/// Versioned encrypted PrivateKeyBundle +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct EncryptedPrivateKeyBundle { + #[prost(oneof="encrypted_private_key_bundle::Version", tags="1")] + pub version: ::core::option::Option, +} +/// Nested message and enum types in `EncryptedPrivateKeyBundle`. +pub mod encrypted_private_key_bundle { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Version { + #[prost(message, tag="1")] + V1(super::EncryptedPrivateKeyBundleV1), + } +} +/// Encoded file descriptor set for the `xmtp.message_contents` package +pub const FILE_DESCRIPTOR_SET: &[u8] = &[ + 0x0a, 0xb4, 0x0d, 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xdd, 0x02, 0x0a, + 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x54, 0x0a, 0x0d, 0x65, 0x63, + 0x64, 0x73, 0x61, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x2e, 0x45, 0x43, 0x44, 0x53, 0x41, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x48, 0x00, 0x52, 0x0c, 0x65, 0x63, 0x64, 0x73, 0x61, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x12, 0x67, 0x0a, 0x14, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, 0x65, 0x63, 0x64, 0x73, 0x61, + 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x2e, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x45, 0x43, 0x44, 0x53, 0x41, 0x43, 0x6f, 0x6d, 0x70, + 0x61, 0x63, 0x74, 0x48, 0x00, 0x52, 0x12, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x45, 0x63, 0x64, + 0x73, 0x61, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x1a, 0x40, 0x0a, 0x0c, 0x45, 0x43, 0x44, + 0x53, 0x41, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x08, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x1a, 0x46, 0x0a, 0x12, 0x57, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x45, 0x43, 0x44, 0x53, 0x41, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, + 0x74, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x72, 0x65, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x79, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x42, 0xca, 0x01, 0x0a, + 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0e, 0x53, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, + 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, + 0xaa, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, + 0x20, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xc3, 0x08, 0x0a, 0x06, 0x12, 0x04, + 0x01, 0x00, 0x1c, 0x01, 0x0a, 0x47, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, 0x12, 0x1a, 0x3d, + 0x20, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, + 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x05, 0x00, + 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x05, 0x00, 0x43, 0x0a, 0x86, 0x01, 0x0a, + 0x02, 0x04, 0x00, 0x12, 0x04, 0x0a, 0x00, 0x1c, 0x01, 0x1a, 0x7a, 0x20, 0x53, 0x69, 0x67, 0x6e, + 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x61, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x70, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x2c, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, + 0x6f, 0x72, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, + 0x63, 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x20, 0x61, 0x67, 0x69, 0x6c, + 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, + 0x11, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x0c, 0x04, 0x0f, 0x05, 0x1a, + 0x2c, 0x20, 0x45, 0x43, 0x44, 0x53, 0x41, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x20, 0x62, 0x69, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x0c, 0x18, 0x0a, 0x3c, 0x0a, 0x06, 0x04, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, 0x08, 0x18, 0x22, 0x2d, 0x20, 0x63, 0x6f, 0x6d, + 0x70, 0x61, 0x63, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x5b, 0x20, 0x52, 0x20, 0x7c, 0x7c, 0x20, 0x53, 0x20, 0x5d, 0x2c, 0x20, + 0x36, 0x34, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0d, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x16, 0x17, 0x0a, 0x1d, 0x0a, 0x06, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x1c, 0x22, 0x0e, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x79, 0x20, 0x62, 0x69, 0x74, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x0e, 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x0f, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x0e, 0x1a, 0x1b, 0x0a, 0xdf, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x03, + 0x01, 0x12, 0x04, 0x14, 0x04, 0x17, 0x05, 0x1a, 0xd0, 0x01, 0x20, 0x45, 0x43, 0x44, 0x53, 0x41, + 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, + 0x79, 0x20, 0x62, 0x69, 0x74, 0x0a, 0x20, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x78, 0x6d, 0x74, 0x70, 0x2d, 0x6a, 0x73, 0x3a, 0x3a, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x4b, 0x65, 0x79, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x57, 0x69, 0x74, 0x68, 0x57, 0x61, + 0x6c, 0x6c, 0x65, 0x74, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2c, 0x20, 0x69, + 0x2e, 0x65, 0x2e, 0x0a, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x39, 0x31, 0x20, 0x73, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x22, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, + 0x65, 0x79, 0x20, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x2e, 0x0a, 0x20, 0x55, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x03, 0x01, 0x01, 0x12, 0x03, 0x14, 0x0c, 0x1e, 0x0a, 0x3c, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x15, 0x08, 0x18, 0x22, 0x2d, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, + 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x5b, 0x20, 0x52, 0x20, 0x7c, 0x7c, 0x20, 0x53, 0x20, 0x5d, 0x2c, 0x20, 0x36, 0x34, 0x20, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x15, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x15, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x15, 0x16, 0x17, 0x0a, 0x1d, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x16, 0x08, 0x1c, 0x22, 0x0e, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, + 0x20, 0x62, 0x69, 0x74, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x01, 0x05, + 0x12, 0x03, 0x16, 0x08, 0x0e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x16, 0x0f, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x16, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x18, + 0x04, 0x1b, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x18, 0x0a, + 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x19, 0x08, 0x27, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x19, 0x08, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x19, 0x15, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x19, 0x25, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x1a, 0x08, 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x1a, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1a, 0x1b, + 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1a, 0x32, 0x33, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x94, 0x12, 0x0a, 0x21, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x69, 0x70, + 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, + 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xee, 0x01, 0x0a, 0x0a, 0x43, 0x69, 0x70, 0x68, 0x65, + 0x72, 0x74, 0x65, 0x78, 0x74, 0x12, 0x6c, 0x0a, 0x16, 0x61, 0x65, 0x73, 0x32, 0x35, 0x36, 0x5f, + 0x67, 0x63, 0x6d, 0x5f, 0x68, 0x6b, 0x64, 0x66, 0x5f, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, + 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x41, 0x65, 0x73, 0x32, 0x35, 0x36, 0x67, + 0x63, 0x6d, 0x48, 0x6b, 0x64, 0x66, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x48, 0x00, 0x52, 0x13, + 0x61, 0x65, 0x73, 0x32, 0x35, 0x36, 0x47, 0x63, 0x6d, 0x48, 0x6b, 0x64, 0x66, 0x53, 0x68, 0x61, + 0x32, 0x35, 0x36, 0x1a, 0x69, 0x0a, 0x13, 0x41, 0x65, 0x73, 0x32, 0x35, 0x36, 0x67, 0x63, 0x6d, + 0x48, 0x6b, 0x64, 0x66, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x12, 0x1b, 0x0a, 0x09, 0x68, 0x6b, + 0x64, 0x66, 0x5f, 0x73, 0x61, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x68, + 0x6b, 0x64, 0x66, 0x53, 0x61, 0x6c, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x63, 0x6d, 0x5f, 0x6e, + 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x63, 0x6d, 0x4e, + 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x42, 0x07, + 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x22, 0xf5, 0x01, 0x0a, 0x15, 0x53, 0x69, 0x67, 0x6e, + 0x65, 0x64, 0x45, 0x63, 0x69, 0x65, 0x73, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, + 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x63, 0x69, 0x65, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x65, 0x63, 0x69, 0x65, 0x73, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x1a, 0x7b, 0x0a, 0x05, 0x45, 0x63, 0x69, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x14, 0x65, + 0x70, 0x68, 0x65, 0x6d, 0x65, 0x72, 0x61, 0x6c, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x65, 0x70, 0x68, 0x65, 0x6d, + 0x65, 0x72, 0x61, 0x6c, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x0e, 0x0a, + 0x02, 0x69, 0x76, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x76, 0x12, 0x10, 0x0a, + 0x03, 0x6d, 0x61, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6d, 0x61, 0x63, 0x12, + 0x1e, 0x0a, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x42, + 0xcb, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0f, 0x43, + 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, + 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, + 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, + 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, + 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xf6, 0x0b, + 0x0a, 0x06, 0x12, 0x04, 0x01, 0x00, 0x2c, 0x01, 0x0a, 0x44, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, + 0x00, 0x12, 0x1a, 0x3a, 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x20, + 0x69, 0x73, 0x20, 0x61, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x73, 0x74, 0x72, + 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, + 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x08, + 0x0a, 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, + 0x05, 0x00, 0x2a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x43, 0x0a, 0x09, 0x0a, + 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x43, 0x0a, 0xe6, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, + 0x04, 0x0e, 0x00, 0x1c, 0x01, 0x1a, 0xd9, 0x01, 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, + 0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x65, + 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x2e, 0x0a, 0x20, 0x49, 0x74, 0x20, 0x69, 0x73, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, + 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, + 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, + 0x20, 0x61, 0x67, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, + 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x69, 0x73, 0x20, 0x61, 0x63, 0x63, 0x6f, 0x6d, 0x70, + 0x61, 0x6e, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x72, 0x79, + 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x65, 0x74, 0x65, 0x72, 0x73, 0x0a, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x6f, 0x73, 0x65, 0x6e, 0x20, 0x65, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x2e, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x12, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x0f, 0x04, 0x11, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x0a, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x10, 0x08, 0x37, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x10, 0x08, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x10, + 0x1c, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x10, 0x35, 0x36, + 0x0a, 0x6c, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x17, 0x04, 0x1b, 0x05, 0x1a, 0x3e, + 0x20, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x41, 0x45, 0x53, + 0x32, 0x35, 0x36, 0x2d, 0x47, 0x43, 0x4d, 0x0a, 0x20, 0x4b, 0x65, 0x79, 0x20, 0x64, 0x65, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x3a, 0x20, 0x48, 0x4b, 0x44, 0x46, 0x2d, 0x53, 0x48, 0x41, 0x32, 0x35, 0x36, 0x0a, 0x32, 0x1e, + 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x45, 0x6e, 0x63, 0x72, 0x79, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x17, 0x0c, 0x1f, 0x0a, 0x19, 0x0a, 0x06, + 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x18, 0x08, 0x1c, 0x22, 0x0a, 0x20, 0x33, 0x32, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x18, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x18, 0x0e, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x18, 0x1a, 0x1b, 0x0a, 0x19, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x19, 0x08, 0x1c, 0x22, 0x0a, 0x20, 0x31, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x19, + 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x19, + 0x0e, 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x19, + 0x1a, 0x1b, 0x0a, 0x22, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, 0x12, 0x03, 0x1a, 0x08, + 0x1a, 0x22, 0x13, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, + 0x05, 0x12, 0x03, 0x1a, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x1a, 0x0e, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x1a, 0x18, 0x19, 0x0a, 0x59, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1f, 0x00, + 0x2c, 0x01, 0x1a, 0x4d, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x45, 0x63, 0x69, 0x65, 0x73, + 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, + 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x45, 0x43, 0x49, 0x45, 0x53, 0x20, 0x65, + 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, + 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1f, 0x08, 0x1d, 0x0a, 0x44, 0x0a, + 0x04, 0x04, 0x01, 0x03, 0x00, 0x12, 0x04, 0x21, 0x04, 0x26, 0x05, 0x1a, 0x36, 0x20, 0x45, 0x63, + 0x69, 0x65, 0x73, 0x20, 0x69, 0x73, 0x20, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, + 0x74, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x75, 0x73, 0x69, 0x6e, + 0x67, 0x20, 0x45, 0x43, 0x49, 0x45, 0x53, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x4d, + 0x41, 0x43, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x03, 0x00, 0x01, 0x12, 0x03, 0x21, 0x0c, + 0x11, 0x0a, 0x19, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x22, 0x08, 0x27, + 0x22, 0x0a, 0x20, 0x36, 0x35, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x22, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x22, 0x0e, 0x22, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x22, 0x25, 0x26, 0x0a, 0x19, 0x0a, 0x06, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x23, 0x08, 0x15, 0x22, 0x0a, 0x20, 0x31, 0x36, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, + 0x01, 0x05, 0x12, 0x03, 0x23, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x23, 0x0e, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x23, 0x13, 0x14, 0x0a, 0x19, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, + 0x02, 0x12, 0x03, 0x24, 0x08, 0x16, 0x22, 0x0a, 0x20, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x24, + 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x24, + 0x0e, 0x11, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x24, + 0x14, 0x15, 0x0a, 0x38, 0x0a, 0x06, 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x12, 0x03, 0x25, 0x08, + 0x1d, 0x22, 0x29, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, + 0x20, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x31, 0x36, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x25, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x25, 0x0e, 0x18, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x01, 0x03, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x25, 0x1b, 0x1c, 0x0a, 0x27, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x29, 0x04, 0x1a, 0x1a, 0x1a, 0x20, 0x73, 0x65, 0x72, 0x69, + 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x45, 0x63, 0x69, 0x65, 0x73, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x29, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x29, 0x0a, + 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x29, 0x18, 0x19, 0x0a, + 0x4b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x2b, 0x04, 0x32, 0x1a, 0x3e, 0x20, 0x73, + 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x68, 0x61, 0x32, + 0x35, 0x36, 0x28, 0x65, 0x63, 0x69, 0x65, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x29, 0x20, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2b, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x2b, 0x24, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x2b, 0x30, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x81, + 0x1a, 0x0a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x20, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xe3, 0x01, + 0x0a, 0x11, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x4e, 0x73, 0x12, 0x77, 0x0a, 0x16, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x5f, + 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x55, 0x6e, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x2e, 0x53, 0x65, 0x63, + 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x65, 0x64, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, + 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x1a, 0x2d, 0x0a, 0x15, 0x53, + 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, + 0x69, 0x6f, 0x6e, 0x22, 0x6e, 0x0a, 0x0f, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6b, 0x65, 0x79, 0x42, 0x79, + 0x74, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, + 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x22, 0xa3, 0x01, 0x0a, 0x15, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x49, 0x0a, + 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, + 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x3f, 0x0a, 0x07, 0x70, 0x72, 0x65, 0x5f, + 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, + 0x79, 0x52, 0x06, 0x70, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x22, 0xa5, 0x02, 0x0a, 0x09, 0x50, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 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, 0x43, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x48, 0x01, 0x52, 0x09, 0x73, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x88, 0x01, 0x01, 0x12, 0x6f, 0x0a, 0x16, 0x73, 0x65, + 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x5f, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x2e, 0x53, 0x65, 0x63, + 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x65, 0x64, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, + 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x1a, 0x2d, 0x0a, 0x15, 0x53, + 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x55, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, + 0x73, 0x73, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, + 0x69, 0x6f, 0x6e, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x22, 0x91, 0x01, 0x0a, 0x0f, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, + 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x43, 0x0a, 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x07, 0x70, 0x72, + 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x06, 0x70, + 0x72, 0x65, 0x4b, 0x65, 0x79, 0x42, 0xca, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x42, 0x0e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, + 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, + 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x4a, 0x95, 0x10, 0x0a, 0x06, 0x12, 0x04, 0x02, 0x00, 0x42, 0x01, 0x0a, 0x7b, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x02, 0x00, 0x12, 0x1a, 0x71, 0x20, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, + 0x75, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, + 0x74, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, + 0x20, 0x6f, 0x66, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2c, 0x0a, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x69, 0x6e, 0x67, 0x20, + 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x04, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x06, 0x00, 0x2a, 0x0a, + 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, + 0x03, 0x08, 0x00, 0x43, 0x0a, 0x84, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0d, 0x00, 0x1a, + 0x01, 0x1a, 0x78, 0x20, 0x55, 0x6e, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x4b, 0x65, 0x79, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, + 0x20, 0x61, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x70, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x2c, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, + 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, + 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, + 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, + 0x6d, 0x20, 0x61, 0x67, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x0d, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x0e, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0e, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x0b, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0e, 0x18, 0x19, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x0f, 0x04, 0x11, 0x05, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x0a, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x10, 0x08, 0x39, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, + 0x12, 0x03, 0x10, 0x08, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x10, 0x1e, 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x37, + 0x38, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x16, 0x04, 0x19, 0x05, 0x1a, + 0x0f, 0x20, 0x45, 0x43, 0x3a, 0x20, 0x53, 0x45, 0x43, 0x50, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x0a, + 0x32, 0x15, 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x6b, 0x65, 0x79, + 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x16, 0x0c, 0x21, 0x0a, 0x50, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x18, 0x08, 0x18, 0x1a, 0x41, 0x20, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x28, 0x30, 0x78, 0x30, 0x34, 0x29, 0x20, 0x5b, 0x20, 0x50, + 0x20, 0x7c, 0x7c, 0x20, 0x58, 0x20, 0x7c, 0x7c, 0x20, 0x59, 0x20, 0x5d, 0x2c, 0x20, 0x36, 0x35, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x18, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x18, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x18, 0x16, 0x17, 0x0a, 0x1e, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1d, + 0x00, 0x20, 0x01, 0x1a, 0x12, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x4b, 0x65, 0x79, 0x20, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, + 0x1d, 0x08, 0x17, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x1e, 0x04, 0x18, + 0x22, 0x1d, 0x20, 0x65, 0x6d, 0x62, 0x65, 0x64, 0x73, 0x20, 0x61, 0x6e, 0x20, 0x55, 0x6e, 0x73, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1e, 0x04, 0x09, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1e, 0x0a, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1e, 0x16, 0x17, 0x0a, 0x1e, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x01, 0x12, 0x03, 0x1f, 0x04, 0x1c, 0x22, 0x11, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x73, 0x20, 0x6b, + 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x1f, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x1f, 0x0e, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x1f, 0x1a, 0x1b, 0x0a, 0x57, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x23, 0x00, 0x28, 0x01, 0x1a, + 0x4b, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, + 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, + 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x61, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x23, 0x08, 0x1d, 0x0a, 0x39, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x25, 0x04, 0x25, 0x1a, 0x2c, 0x20, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, + 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x25, 0x04, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x25, 0x14, 0x20, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x25, 0x23, 0x24, 0x0a, 0x3a, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x27, 0x04, 0x20, 0x1a, 0x2d, 0x20, 0x50, 0x72, 0x65, + 0x2d, 0x6b, 0x65, 0x79, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x27, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x27, 0x14, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x27, 0x1e, 0x1f, 0x0a, 0x86, 0x01, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x2e, 0x00, 0x39, 0x01, + 0x1a, 0x70, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x20, 0x72, 0x65, 0x70, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, + 0x2c, 0x0a, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x20, + 0x75, 0x6e, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x20, 0x61, + 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x20, 0x61, 0x67, 0x69, 0x6c, 0x69, 0x74, 0x79, + 0x2e, 0x0a, 0x32, 0x08, 0x20, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x03, 0x01, 0x12, 0x03, 0x2e, 0x08, 0x11, 0x0a, 0x1d, 0x0a, 0x04, 0x04, 0x03, 0x03, 0x00, + 0x12, 0x04, 0x30, 0x04, 0x33, 0x05, 0x1a, 0x0f, 0x20, 0x54, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x30, 0x0c, 0x21, 0x0a, 0x50, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x32, 0x08, 0x18, 0x1a, 0x41, 0x20, 0x75, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, + 0x73, 0x65, 0x64, 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x70, + 0x72, 0x65, 0x66, 0x69, 0x78, 0x20, 0x28, 0x30, 0x78, 0x30, 0x34, 0x29, 0x20, 0x5b, 0x20, 0x50, + 0x20, 0x7c, 0x7c, 0x20, 0x58, 0x20, 0x7c, 0x7c, 0x20, 0x59, 0x20, 0x5d, 0x2c, 0x20, 0x36, 0x35, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x32, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x32, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x32, 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, + 0x03, 0x34, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, 0x12, 0x03, 0x34, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x34, 0x0b, 0x14, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x34, 0x17, 0x18, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x35, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x04, 0x12, 0x03, 0x35, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x35, 0x0d, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x35, 0x17, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x35, 0x23, 0x24, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x08, 0x00, 0x12, 0x04, 0x36, 0x04, 0x38, + 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x08, 0x00, 0x01, 0x12, 0x03, 0x36, 0x0a, 0x0f, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x37, 0x08, 0x39, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, 0x03, 0x37, 0x08, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x37, 0x1e, 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x37, 0x37, 0x38, 0x0a, 0x9a, 0x01, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x3d, + 0x00, 0x42, 0x01, 0x1a, 0x8d, 0x01, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, + 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x67, 0x72, 0x61, 0x70, 0x68, 0x69, + 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x61, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2c, + 0x0a, 0x20, 0x62, 0x6f, 0x74, 0x68, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x73, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, + 0x74, 0x68, 0x65, 0x69, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x3d, 0x08, 0x17, 0x0a, + 0x39, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x3f, 0x04, 0x1f, 0x1a, 0x2c, 0x20, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x4d, 0x55, 0x53, 0x54, + 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x00, 0x06, 0x12, 0x03, 0x3f, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x3f, 0x0e, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x3f, 0x1d, 0x1e, 0x0a, 0x3a, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x41, 0x04, + 0x1a, 0x1a, 0x2d, 0x20, 0x50, 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x20, 0x4d, 0x55, 0x53, 0x54, + 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x20, 0x6b, 0x65, 0x79, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x41, 0x04, 0x0d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x41, 0x0e, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x41, 0x18, 0x19, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, 0x0a, 0xe5, 0x1c, 0x0a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x1a, + 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2f, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xec, 0x03, 0x0a, 0x0c, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x45, 0x0a, 0x07, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x56, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x12, 0x6e, 0x0a, 0x16, 0x61, 0x65, 0x73, 0x32, 0x35, 0x36, 0x5f, 0x67, 0x63, + 0x6d, 0x5f, 0x68, 0x6b, 0x64, 0x66, 0x5f, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x49, 0x6e, 0x76, 0x69, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x2e, 0x41, 0x65, 0x73, 0x32, 0x35, 0x36, 0x67, + 0x63, 0x6d, 0x48, 0x6b, 0x64, 0x66, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x48, 0x00, 0x52, 0x13, + 0x61, 0x65, 0x73, 0x32, 0x35, 0x36, 0x47, 0x63, 0x6d, 0x48, 0x6b, 0x64, 0x66, 0x53, 0x68, 0x61, + 0x32, 0x35, 0x36, 0x1a, 0x38, 0x0a, 0x13, 0x41, 0x65, 0x73, 0x32, 0x35, 0x36, 0x67, 0x63, 0x6d, + 0x48, 0x6b, 0x64, 0x66, 0x73, 0x68, 0x61, 0x32, 0x35, 0x36, 0x12, 0x21, 0x0a, 0x0c, 0x6b, 0x65, + 0x79, 0x5f, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0b, 0x6b, 0x65, 0x79, 0x4d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x1a, 0xc6, 0x01, + 0x0a, 0x07, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x55, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, + 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x3b, 0x0a, 0x0d, 0x4d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 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, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0c, 0x0a, 0x0a, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xcb, 0x01, 0x0a, 0x18, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, + 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, + 0x31, 0x12, 0x44, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, + 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x4a, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, + 0x69, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, + 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, + 0x65, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, + 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x4e, 0x73, 0x22, 0x7a, 0x0a, 0x12, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, 0x76, 0x69, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x63, + 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, + 0x78, 0x74, 0x52, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x22, 0x5a, + 0x0a, 0x10, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x02, 0x76, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, 0x76, + 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x48, 0x00, 0x52, 0x02, 0x76, 0x31, 0x42, + 0x09, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0xcb, 0x01, 0x0a, 0x19, 0x63, + 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0f, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, + 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, + 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xf7, 0x12, 0x0a, 0x06, 0x12, 0x04, 0x03, + 0x00, 0x47, 0x01, 0x0a, 0xd4, 0x01, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x03, 0x00, 0x12, 0x1a, 0xc9, + 0x01, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x73, 0x20, + 0x75, 0x73, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x69, 0x74, 0x69, + 0x61, 0x74, 0x6f, 0x72, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x20, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x69, 0x6e, 0x74, + 0x6f, 0x20, 0x61, 0x20, 0x6e, 0x65, 0x77, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x68, 0x6f, + 0x73, 0x65, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x20, + 0x61, 0x6e, 0x64, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, + 0x63, 0x68, 0x65, 0x6d, 0x65, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x65, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, + 0x03, 0x05, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x07, 0x00, 0x2b, 0x0a, + 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x08, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, + 0x03, 0x0a, 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x0a, 0x00, 0x43, 0x0a, + 0x24, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0e, 0x00, 0x2a, 0x01, 0x1a, 0x18, 0x20, 0x55, 0x6e, + 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x20, 0x56, 0x31, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x08, + 0x14, 0x0a, 0x44, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x11, 0x04, 0x13, 0x05, 0x1a, + 0x36, 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x73, 0x0a, 0x20, + 0x41, 0x45, 0x53, 0x32, 0x35, 0x36, 0x2d, 0x47, 0x43, 0x4d, 0x2d, 0x48, 0x4b, 0x44, 0x46, 0x2d, + 0x53, 0x48, 0x41, 0x32, 0x35, 0x36, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, + 0x12, 0x03, 0x11, 0x0c, 0x1f, 0x0a, 0x3b, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x12, 0x08, 0x1f, 0x22, 0x2c, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x6c, 0x79, 0x20, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x28, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x29, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x12, + 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x12, + 0x0e, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x12, + 0x1d, 0x1e, 0x0a, 0x20, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x01, 0x12, 0x04, 0x16, 0x04, 0x1c, 0x05, + 0x1a, 0x12, 0x20, 0x54, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x03, 0x01, 0x01, 0x12, 0x03, 0x16, + 0x0c, 0x13, 0x0a, 0x3a, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, 0x12, 0x03, 0x18, 0x08, + 0x23, 0x1a, 0x2b, 0x20, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x62, 0x65, 0x20, 0x61, 0x20, 0x55, 0x52, 0x49, 0x20, 0x28, 0x69, 0x65, 0x20, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x6f, 0x31, 0x29, 0x0a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x18, 0x08, 0x0e, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x18, 0x0f, 0x1e, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, 0x21, 0x22, 0x0a, 0x86, + 0x01, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x01, 0x02, 0x01, 0x12, 0x03, 0x1b, 0x08, 0x29, 0x1a, 0x77, + 0x20, 0x4b, 0x65, 0x79, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x6d, 0x61, 0x70, 0x20, 0x6f, + 0x66, 0x20, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, 0x6d, 0x65, 0x74, + 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6f, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x0a, 0x20, + 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x64, 0x65, 0x76, 0x65, + 0x6c, 0x6f, 0x70, 0x65, 0x72, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x63, 0x6f, 0x75, 0x6c, 0x64, + 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x1b, 0x08, 0x1b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x1b, 0x1c, 0x24, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x01, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x1b, 0x27, 0x28, 0x0a, 0x92, 0x01, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x20, 0x04, 0x15, 0x1a, 0x84, 0x01, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x6e, + 0x61, 0x6d, 0x65, 0x20, 0x63, 0x68, 0x6f, 0x73, 0x65, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x0a, 0x20, 0x49, 0x74, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x72, 0x61, + 0x6e, 0x64, 0x6f, 0x6d, 0x6c, 0x79, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x28, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x20, 0x3e, + 0x3d, 0x20, 0x33, 0x32, 0x29, 0x2c, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x62, 0x61, 0x73, + 0x65, 0x36, 0x34, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x6f, 0x75, 0x74, 0x20, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x20, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x20, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x20, 0x13, 0x14, 0x0a, 0x31, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, + 0x23, 0x04, 0x18, 0x1a, 0x24, 0x20, 0x41, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x20, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x23, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x23, 0x0c, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x23, 0x16, 0x17, 0x0a, 0x49, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, 0x04, 0x26, 0x04, 0x29, + 0x05, 0x1a, 0x3b, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x20, 0x61, 0x6e, + 0x64, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, 0x12, 0x03, 0x26, 0x0a, 0x14, 0x0a, 0x52, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x28, 0x08, 0x37, 0x1a, 0x45, 0x20, 0x53, 0x70, 0x65, 0x63, + 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, + 0x63, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, 0x74, + 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x6c, 0x79, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x28, 0x08, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x28, 0x1c, 0x32, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x28, 0x35, 0x36, 0x0a, 0x83, 0x02, 0x0a, 0x02, 0x04, + 0x01, 0x12, 0x04, 0x31, 0x00, 0x35, 0x01, 0x1a, 0xf6, 0x01, 0x20, 0x53, 0x65, 0x61, 0x6c, 0x65, + 0x64, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x56, 0x31, 0x20, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x0a, 0x20, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x63, + 0x61, 0x72, 0x72, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x75, 0x6e, 0x65, 0x6e, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x74, 0x68, 0x75, 0x73, 0x20, 0x72, 0x65, 0x61, + 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, + 0x77, 0x6f, 0x72, 0x6b, 0x0a, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x68, 0x6f, 0x77, 0x65, + 0x76, 0x65, 0x72, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, + 0x64, 0x61, 0x74, 0x61, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, 0x68, 0x65, 0x20, 0x41, 0x45, + 0x41, 0x44, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x0a, 0x20, + 0x74, 0x6f, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, + 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x6f, 0x64, 0x79, 0x2c, 0x20, + 0x74, 0x68, 0x75, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x74, + 0x61, 0x6d, 0x70, 0x65, 0x72, 0x20, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x31, 0x08, 0x20, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x32, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x32, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x32, 0x1a, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x32, 0x23, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x33, 0x04, 0x28, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x33, 0x04, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x33, 0x1a, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x33, 0x26, 0x27, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, + 0x02, 0x02, 0x12, 0x03, 0x34, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, + 0x12, 0x03, 0x34, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x34, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x03, 0x12, 0x03, 0x34, 0x18, + 0x19, 0x0a, 0xe4, 0x01, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x3b, 0x00, 0x40, 0x01, 0x1a, 0xd7, + 0x01, 0x20, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x20, 0x56, 0x31, 0x0a, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x64, + 0x65, 0x72, 0x69, 0x76, 0x65, 0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x20, 0x72, 0x65, + 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x27, 0x73, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x20, 0x75, 0x73, 0x69, + 0x6e, 0x67, 0x20, 0x73, 0x69, 0x6d, 0x70, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x58, 0x33, + 0x44, 0x48, 0x20, 0x77, 0x68, 0x65, 0x72, 0x65, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, + 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x65, 0x70, 0x68, 0x65, 0x6d, 0x65, 0x72, 0x61, 0x6c, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x69, 0x73, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x64, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, 0x73, 0x20, 0x70, + 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, + 0x03, 0x3b, 0x08, 0x1a, 0x0a, 0x56, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x3d, 0x04, + 0x1b, 0x1a, 0x49, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x53, 0x65, 0x61, 0x6c, + 0x65, 0x64, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x56, 0x31, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x73, 0x73, + 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, + 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3d, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x3d, 0x0a, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x3d, 0x19, 0x1a, 0x0a, 0x46, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x3f, 0x04, 0x1e, 0x1a, 0x39, 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, + 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, + 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3f, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3f, 0x0f, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x3f, 0x1c, 0x1d, 0x0a, 0x29, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, + 0x43, 0x00, 0x47, 0x01, 0x1a, 0x1d, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, + 0x20, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x20, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x43, 0x08, 0x18, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x08, 0x00, 0x12, 0x04, 0x44, 0x04, 0x46, 0x05, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x08, 0x00, 0x01, 0x12, 0x03, 0x44, 0x0a, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x03, 0x02, 0x00, 0x12, 0x03, 0x45, 0x08, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x45, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x45, 0x1b, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x45, + 0x20, 0x21, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xa0, 0x07, 0x0a, 0x2d, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, + 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb6, 0x01, 0x0a, 0x15, 0x43, 0x6f, 0x6e, 0x76, 0x65, + 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, + 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x65, + 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, 0x45, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x78, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, 0x2e, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x42, + 0xd6, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x1a, 0x43, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, + 0x65, 0x6e, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, + 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, + 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0x9a, 0x03, 0x0a, 0x06, 0x12, 0x04, 0x01, + 0x00, 0x10, 0x01, 0x0a, 0x2b, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, 0x12, 0x1a, 0x21, 0x20, + 0x48, 0x6f, 0x6c, 0x64, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, + 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x0a, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, + 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, 0x43, 0x0a, + 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x43, 0x0a, 0x51, 0x0a, 0x02, 0x04, 0x00, + 0x12, 0x04, 0x0b, 0x00, 0x10, 0x01, 0x1a, 0x45, 0x20, 0x41, 0x20, 0x6c, 0x69, 0x67, 0x68, 0x74, + 0x20, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x20, 0x63, + 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x20, 0x6e, 0x6f, 0x20, 0x64, 0x65, 0x63, + 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0b, 0x08, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x0c, 0x04, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x0c, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0c, + 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0c, 0x13, 0x14, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0d, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0d, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x0d, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x0d, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, + 0x03, 0x0e, 0x04, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0e, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x0b, 0x15, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0e, 0x18, 0x19, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x0f, 0x04, 0x3b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x0f, 0x04, 0x2e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x0f, 0x2f, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, + 0x12, 0x03, 0x0f, 0x39, 0x3a, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xdd, 0x18, + 0x0a, 0x1e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x5f, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x73, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x95, 0x01, 0x0a, + 0x0d, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x12, 0x21, + 0x0a, 0x0c, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x49, + 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x74, 0x79, 0x70, 0x65, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x6a, 0x6f, 0x72, 0x12, + 0x23, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6e, 0x6f, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x4d, + 0x69, 0x6e, 0x6f, 0x72, 0x22, 0x83, 0x03, 0x0a, 0x0e, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x49, 0x64, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x12, 0x55, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x45, 0x6e, + 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2e, 0x50, 0x61, 0x72, + 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x1f, 0x0a, 0x08, 0x66, 0x61, 0x6c, 0x6c, + 0x62, 0x61, 0x63, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x66, 0x61, + 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x88, 0x01, 0x01, 0x12, 0x49, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x48, 0x01, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x88, 0x01, 0x01, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x1a, 0x3d, + 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 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, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x0b, 0x0a, + 0x09, 0x5f, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x42, 0x0e, 0x0a, 0x0c, 0x5f, 0x63, + 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xaf, 0x01, 0x0a, 0x0d, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, + 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, + 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x44, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, + 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x09, + 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x2a, 0x3c, 0x0a, 0x0b, + 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x17, 0x0a, 0x13, 0x43, + 0x4f, 0x4d, 0x50, 0x52, 0x45, 0x53, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x46, 0x4c, 0x41, + 0x54, 0x45, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x43, 0x4f, 0x4d, 0x50, 0x52, 0x45, 0x53, 0x53, + 0x49, 0x4f, 0x4e, 0x5f, 0x47, 0x5a, 0x49, 0x50, 0x10, 0x01, 0x42, 0xc8, 0x01, 0x0a, 0x19, 0x63, + 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0c, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, 0x58, + 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, 0x74, + 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, + 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xfd, 0x0f, 0x0a, 0x06, 0x12, 0x04, 0x01, 0x00, 0x36, 0x01, + 0x0a, 0x2f, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, 0x12, 0x1a, 0x25, 0x20, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x65, 0x6e, 0x63, + 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x75, 0x72, 0x65, 0x73, + 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x05, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x06, 0x00, + 0x2a, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x08, 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x08, 0x00, 0x43, 0x0a, 0x58, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0c, 0x00, + 0x11, 0x01, 0x1a, 0x4c, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x49, 0x64, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x20, + 0x6f, 0x66, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, + 0x64, 0x20, 0x69, 0x6e, 0x20, 0x61, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x0c, 0x08, 0x15, 0x0a, 0x34, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x0d, 0x04, 0x1c, 0x22, 0x27, 0x20, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x69, 0x74, 0x79, 0x20, 0x67, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0d, 0x04, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x0b, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0d, 0x1a, 0x1b, 0x0a, 0x1e, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0e, 0x04, 0x17, 0x22, 0x11, 0x20, 0x74, 0x79, 0x70, 0x65, + 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x0e, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x0e, 0x15, 0x16, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x0f, 0x04, 0x1d, 0x22, 0x1b, 0x20, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x20, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x0f, 0x04, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x0f, 0x0b, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x0f, 0x1b, 0x1c, 0x0a, 0x28, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x03, 0x12, 0x03, 0x10, 0x04, 0x1d, 0x22, 0x1b, 0x20, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x20, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x10, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x10, 0x0b, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x10, 0x1b, 0x1c, 0x0a, 0x67, + 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, 0x15, 0x00, 0x18, 0x01, 0x1a, 0x5b, 0x20, 0x52, 0x65, 0x63, + 0x6f, 0x67, 0x6e, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x73, 0x0a, 0x20, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x6c, 0x69, 0x6e, 0x74, 0x3a, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, + 0x65, 0x20, 0x45, 0x4e, 0x55, 0x4d, 0x5f, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x5f, 0x4e, 0x41, 0x4d, + 0x45, 0x53, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x45, 0x4e, + 0x44, 0x5f, 0x57, 0x49, 0x54, 0x48, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, 0x03, + 0x15, 0x05, 0x10, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, 0x12, 0x03, 0x16, 0x04, 0x1c, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x16, 0x04, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x16, 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, + 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x17, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x17, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, + 0x12, 0x03, 0x17, 0x17, 0x18, 0x0a, 0xa3, 0x01, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1d, 0x00, + 0x2b, 0x01, 0x1a, 0x96, 0x01, 0x20, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x79, 0x69, + 0x6e, 0x67, 0x20, 0x69, 0x74, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, + 0x69, 0x72, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, + 0x20, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x01, 0x01, 0x12, 0x03, 0x1d, 0x08, 0x16, 0x0a, 0x65, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, + 0x03, 0x20, 0x04, 0x1b, 0x1a, 0x58, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x20, 0x75, + 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x0a, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x20, 0x64, 0x65, 0x63, 0x6f, 0x64, + 0x69, 0x6e, 0x67, 0x20, 0x6d, 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x72, 0x79, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x20, 0x04, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x20, 0x12, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x20, 0x19, 0x1a, 0x0a, 0x54, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, + 0x12, 0x03, 0x22, 0x04, 0x27, 0x1a, 0x47, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, + 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, + 0x74, 0x65, 0x72, 0x73, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x20, 0x74, 0x6f, + 0x20, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x6c, 0x79, 0x20, 0x64, 0x65, 0x63, 0x6f, 0x64, + 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x22, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x22, 0x18, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x22, 0x25, 0x26, 0x0a, 0x84, 0x01, 0x0a, 0x04, 0x04, 0x01, 0x02, + 0x02, 0x12, 0x03, 0x25, 0x04, 0x21, 0x1a, 0x77, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x20, 0x66, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, 0x6b, 0x20, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x62, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x63, 0x61, 0x73, 0x65, 0x0a, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, + 0x74, 0x20, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x20, 0x6f, 0x72, 0x20, 0x72, 0x65, 0x6e, 0x64, + 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x02, 0x04, 0x12, 0x03, 0x25, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x02, 0x05, 0x12, 0x03, 0x25, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x02, 0x02, 0x01, 0x12, 0x03, 0x25, 0x14, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x25, 0x1f, 0x20, 0x0a, 0x6e, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x03, 0x12, + 0x03, 0x28, 0x04, 0x29, 0x1a, 0x61, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x20, + 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x3b, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x20, 0x69, 0x6e, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x20, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, + 0x74, 0x6f, 0x0a, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x04, + 0x12, 0x03, 0x28, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x06, 0x12, 0x03, + 0x28, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x01, 0x12, 0x03, 0x28, 0x19, + 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x03, 0x03, 0x12, 0x03, 0x28, 0x27, 0x28, 0x0a, + 0x25, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x04, 0x12, 0x03, 0x2a, 0x04, 0x16, 0x1a, 0x18, 0x20, 0x65, + 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x69, + 0x74, 0x73, 0x65, 0x6c, 0x66, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x05, 0x12, + 0x03, 0x2a, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2a, + 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2a, 0x14, 0x15, + 0x0a, 0x43, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x2e, 0x00, 0x36, 0x01, 0x1a, 0x37, 0x20, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x20, 0x61, 0x74, 0x74, + 0x61, 0x63, 0x68, 0x65, 0x73, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x20, 0x74, 0x6f, 0x20, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x08, + 0x15, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x30, 0x04, 0x16, 0x1a, 0x1d, + 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x45, 0x6e, + 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x30, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x30, 0x0a, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x30, 0x14, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x31, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x31, + 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x31, 0x1a, 0x20, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x31, 0x23, 0x24, 0x0a, 0x8a, + 0x01, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x35, 0x04, 0x1c, 0x1a, 0x7d, 0x20, 0x4d, + 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x61, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x6e, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x79, 0x6c, 0x6f, + 0x61, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x2c, 0x0a, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x27, + 0x73, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x35, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x35, 0x0e, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x35, 0x1a, 0x1b, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xf3, 0x07, + 0x0a, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x1e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdb, 0x01, 0x0a, 0x09, 0x43, 0x6f, + 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x70, 0x61, 0x72, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, + 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x52, 0x05, 0x70, + 0x61, 0x72, 0x74, 0x73, 0x1a, 0x90, 0x01, 0x0a, 0x04, 0x50, 0x61, 0x72, 0x74, 0x12, 0x3b, 0x0a, + 0x04, 0x70, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x48, 0x00, 0x52, 0x04, 0x70, 0x61, 0x72, 0x74, 0x12, 0x40, 0x0a, 0x09, 0x63, 0x6f, + 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x48, + 0x00, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x42, 0x09, 0x0a, 0x07, + 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0xca, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, + 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, 0x58, 0x6d, + 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, 0x74, 0x70, + 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x15, 0x58, + 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xe4, 0x03, 0x0a, 0x06, 0x12, 0x04, 0x01, 0x00, 0x15, 0x01, 0x0a, + 0x21, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, 0x12, 0x1a, 0x17, 0x20, 0x43, 0x6f, 0x6d, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x65, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, + 0x03, 0x00, 0x12, 0x03, 0x05, 0x00, 0x28, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x07, 0x00, + 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x07, 0x00, 0x43, 0x0a, 0x4c, 0x0a, 0x02, + 0x04, 0x00, 0x12, 0x04, 0x0b, 0x00, 0x15, 0x01, 0x1a, 0x40, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x65, 0x20, 0x69, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x69, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6f, + 0x72, 0x67, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x65, 0x20, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x0b, 0x08, 0x11, 0x0a, 0x42, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, + 0x0d, 0x04, 0x12, 0x05, 0x1a, 0x34, 0x20, 0x50, 0x61, 0x72, 0x74, 0x20, 0x72, 0x65, 0x70, 0x72, + 0x65, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6f, 0x6e, 0x65, 0x20, 0x73, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x03, 0x00, 0x01, 0x12, 0x03, 0x0d, 0x0c, 0x10, 0x0a, 0x0e, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, + 0x08, 0x00, 0x12, 0x04, 0x0e, 0x08, 0x11, 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, + 0x08, 0x00, 0x01, 0x12, 0x03, 0x0e, 0x0e, 0x15, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x0f, 0x0c, 0x24, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x0f, 0x0c, 0x1a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x0f, 0x1b, 0x1f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x0f, 0x22, 0x23, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x01, 0x12, 0x03, 0x10, 0x0c, 0x24, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x10, 0x0c, 0x15, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x10, 0x16, 0x1f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x10, 0x22, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x14, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x14, 0x04, + 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x14, 0x0d, 0x11, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x14, 0x12, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x14, 0x1a, 0x1b, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, 0x0a, 0xd2, 0x0b, 0x0a, 0x1e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x21, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, + 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0x58, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, + 0x65, 0x56, 0x31, 0x12, 0x45, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x75, 0x6e, 0x64, 0x6c, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, + 0x09, 0x6b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x5e, 0x0a, 0x0f, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x32, 0x12, 0x4b, 0x0a, + 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, + 0x09, 0x6b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x22, 0x8e, 0x01, 0x0a, 0x0d, 0x43, + 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x38, 0x0a, 0x02, + 0x76, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x31, + 0x48, 0x00, 0x52, 0x02, 0x76, 0x31, 0x12, 0x38, 0x0a, 0x02, 0x76, 0x32, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x02, 0x76, 0x32, + 0x42, 0x09, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0xc8, 0x01, 0x0a, 0x19, + 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0c, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, + 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, + 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xd7, 0x06, 0x0a, 0x06, 0x12, 0x04, 0x05, 0x00, 0x1f, + 0x01, 0x0a, 0xc9, 0x02, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x05, 0x00, 0x12, 0x1a, 0xbe, 0x02, 0x20, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x63, 0x74, 0x20, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x61, 0x64, 0x76, 0x65, + 0x72, 0x74, 0x69, 0x73, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x27, 0x73, 0x20, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x79, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x77, 0x65, 0x6c, 0x6c, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x74, 0x6f, 0x70, 0x69, 0x63, + 0x73, 0x20, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, + 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x69, 0x70, 0x61, 0x6e, 0x74, 0x73, 0x0a, 0x20, 0x63, 0x61, + 0x6e, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6d, 0x20, 0x77, 0x68, 0x65, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x77, 0x69, 0x73, 0x68, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6f, + 0x6d, 0x6d, 0x75, 0x6e, 0x69, 0x63, 0x61, 0x74, 0x65, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x70, 0x75, + 0x62, 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x75, 0x73, + 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x72, 0x69, 0x76, + 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6b, 0x65, 0x79, + 0x73, 0x0a, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x6d, 0x65, 0x74, 0x61, + 0x2d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x2c, 0x20, 0x65, 0x2e, 0x67, 0x2e, 0x20, + 0x69, 0x6e, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x07, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x09, + 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0b, 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, + 0x08, 0x0b, 0x12, 0x03, 0x0b, 0x00, 0x43, 0x0a, 0x5a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x10, + 0x00, 0x12, 0x01, 0x1a, 0x4e, 0x20, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x3a, 0x20, 0x55, 0x73, + 0x65, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x62, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x56, 0x31, + 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, + 0x73, 0x2e, 0x0a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, + 0x79, 0x73, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x62, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x10, 0x08, 0x17, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x11, 0x04, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, 0x11, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x11, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x11, 0x21, 0x22, 0x0a, 0x38, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x15, 0x00, + 0x17, 0x01, 0x1a, 0x2c, 0x20, 0x55, 0x73, 0x65, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x62, 0x75, + 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x56, 0x32, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67, 0x20, 0x53, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x73, 0x2e, 0x0a, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x16, 0x04, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x16, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x16, 0x1a, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x16, 0x27, 0x28, 0x0a, 0x25, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x1a, 0x00, 0x1f, 0x01, 0x1a, + 0x19, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x63, 0x74, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, + 0x01, 0x12, 0x03, 0x1a, 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x02, 0x08, 0x00, 0x12, 0x04, + 0x1b, 0x04, 0x1e, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, 0x01, 0x12, 0x03, 0x1b, + 0x0a, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x1c, 0x08, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1c, 0x08, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1c, 0x18, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1c, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x1d, 0x08, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, + 0x03, 0x1d, 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1d, + 0x18, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1d, 0x1d, 0x1e, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0x99, 0x1d, 0x0a, 0x1e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xb5, 0x01, 0x0a, 0x0f, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x31, 0x12, 0x3e, 0x0a, 0x06, 0x73, + 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, + 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, + 0x64, 0x6c, 0x65, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x44, 0x0a, 0x09, 0x72, + 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, + 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x09, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, + 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, + 0x71, 0x0a, 0x09, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x56, 0x31, 0x12, 0x21, 0x0a, 0x0c, + 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x41, 0x0a, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, + 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x52, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, + 0x78, 0x74, 0x22, 0x46, 0x0a, 0x0f, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x56, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x5f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, + 0x65, 0x64, 0x4e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x22, 0x71, 0x0a, 0x09, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x56, 0x32, 0x12, 0x21, 0x0a, 0x0c, 0x68, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x41, 0x0a, 0x0a, 0x63, 0x69, + 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, + 0x74, 0x52, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x22, 0x7c, 0x0a, + 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x32, 0x0a, 0x02, 0x76, 0x31, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x56, 0x31, 0x48, 0x00, 0x52, 0x02, 0x76, 0x31, 0x12, 0x32, 0x0a, 0x02, + 0x76, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x02, 0x76, 0x32, + 0x42, 0x09, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xed, 0x02, 0x0a, 0x0e, + 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x27, + 0x0a, 0x0f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x65, 0x6e, 0x64, 0x65, + 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x30, + 0x0a, 0x11, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, + 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x10, 0x72, 0x65, 0x63, + 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x88, 0x01, 0x01, + 0x12, 0x17, 0x0a, 0x07, 0x73, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x06, 0x73, 0x65, 0x6e, 0x74, 0x4e, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x6f, 0x70, 0x69, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x70, 0x69, 0x63, 0x12, 0x50, + 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x63, 0x65, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, + 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x72, 0x65, 0x63, 0x69, 0x70, 0x69, + 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x42, 0xc8, 0x01, 0x0a, 0x19, + 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0c, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, 0x58, 0xaa, 0x02, 0x14, + 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, 0x02, 0x20, 0x58, 0x6d, + 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, + 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xc3, 0x12, 0x0a, 0x06, 0x12, 0x04, 0x01, 0x00, 0x45, + 0x01, 0x0a, 0x4a, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x01, 0x00, 0x12, 0x1a, 0x40, 0x20, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x75, 0x73, 0x65, 0x72, 0x20, 0x63, 0x6f, + 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x03, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, 0x03, 0x05, + 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x06, 0x00, 0x37, 0x0a, 0x09, 0x0a, + 0x02, 0x03, 0x02, 0x12, 0x03, 0x07, 0x00, 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x09, + 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, 0x0b, 0x12, 0x03, 0x09, 0x00, 0x43, 0x0a, 0x8c, 0x01, + 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x10, 0x00, 0x14, 0x01, 0x1a, 0x72, 0x20, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x65, + 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x73, 0x65, 0x70, 0x61, 0x72, 0x61, 0x74, 0x65, 0x6c, + 0x79, 0x20, 0x61, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x75, 0x73, 0x65, 0x64, 0x0a, 0x20, 0x61, 0x73, + 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x32, 0x0c, + 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x56, 0x31, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x10, 0x08, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x11, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, 0x03, + 0x11, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x11, 0x14, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x11, 0x1d, 0x1e, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x12, 0x04, 0x22, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x12, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x12, 0x14, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x12, 0x20, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x13, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x13, 0x04, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x13, 0x0b, 0x14, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x13, 0x17, 0x18, 0x0a, 0x37, 0x0a, + 0x02, 0x04, 0x01, 0x12, 0x04, 0x17, 0x00, 0x1b, 0x01, 0x1a, 0x2b, 0x20, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x6f, 0x70, 0x20, 0x6c, + 0x65, 0x76, 0x65, 0x6c, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x20, 0x65, 0x6c, + 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x17, + 0x08, 0x11, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x18, 0x04, 0x1b, 0x22, + 0x26, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x65, + 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x56, 0x31, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x18, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x18, 0x0a, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x18, 0x19, + 0x1a, 0x0a, 0x47, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x1a, 0x04, 0x1e, 0x1a, 0x3a, + 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x45, 0x6e, 0x63, 0x6f, 0x64, + 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x06, 0x12, 0x03, 0x1a, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1a, 0x0f, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x1a, 0x1c, 0x1d, 0x0a, 0x88, 0x02, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x23, 0x00, 0x28, + 0x01, 0x1a, 0xed, 0x01, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x68, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x20, 0x63, 0x61, 0x72, 0x72, 0x69, 0x65, 0x73, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, + 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x2c, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x0a, + 0x20, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x79, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2e, 0x20, 0x49, 0x74, 0x20, 0x69, + 0x73, 0x20, 0x68, 0x6f, 0x77, 0x65, 0x76, 0x65, 0x72, 0x20, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, + 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x20, 0x61, 0x73, 0x20, 0x61, 0x73, 0x73, 0x6f, 0x63, + 0x69, 0x61, 0x74, 0x65, 0x64, 0x20, 0x64, 0x61, 0x74, 0x61, 0x0a, 0x20, 0x6f, 0x66, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x41, 0x45, 0x41, 0x44, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x65, + 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2c, 0x0a, + 0x20, 0x74, 0x68, 0x75, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x69, 0x6e, 0x67, 0x20, + 0x74, 0x61, 0x6d, 0x70, 0x65, 0x72, 0x20, 0x65, 0x76, 0x69, 0x64, 0x65, 0x6e, 0x63, 0x65, 0x2e, + 0x0a, 0x32, 0x0c, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x56, 0x32, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x23, 0x08, 0x17, 0x0a, 0x35, 0x0a, 0x04, 0x04, + 0x02, 0x02, 0x00, 0x12, 0x03, 0x25, 0x04, 0x1a, 0x1a, 0x28, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x69, 0x6d, + 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x25, 0x04, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x25, 0x0b, 0x15, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x25, 0x18, 0x19, 0x0a, 0x2f, 0x0a, 0x04, + 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x27, 0x04, 0x15, 0x1a, 0x22, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x74, 0x6f, 0x70, 0x69, 0x63, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x6e, 0x67, 0x73, 0x20, 0x74, 0x6f, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x05, 0x12, 0x03, 0x27, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x27, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x03, 0x12, 0x03, 0x27, 0x13, 0x14, 0x0a, 0x4d, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x2b, + 0x00, 0x2f, 0x01, 0x1a, 0x41, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, + 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x6f, 0x64, + 0x65, 0x64, 0x20, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x70, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x2b, + 0x08, 0x11, 0x0a, 0x33, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x2c, 0x04, 0x1b, 0x22, + 0x26, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x20, 0x65, + 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x20, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x56, 0x32, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x05, + 0x12, 0x03, 0x2c, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x2c, 0x0a, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2c, 0x19, + 0x1a, 0x0a, 0x46, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x2e, 0x04, 0x1e, 0x1a, 0x39, + 0x20, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, 0x70, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, 0x53, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x2e, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x2e, 0x0f, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2e, 0x1c, 0x1d, 0x0a, 0x1f, 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x32, 0x00, 0x37, 0x01, 0x1a, + 0x13, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x32, 0x08, 0x0f, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x33, 0x04, 0x36, 0x05, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x33, 0x0a, 0x11, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x34, 0x08, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x06, 0x12, 0x03, 0x34, 0x08, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x34, 0x12, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x34, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x35, 0x08, 0x19, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x35, 0x08, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x35, 0x12, 0x14, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x35, 0x17, 0x18, 0x0a, 0xae, 0x01, 0x0a, 0x02, 0x04, + 0x05, 0x12, 0x04, 0x3c, 0x00, 0x45, 0x01, 0x1a, 0xa1, 0x01, 0x20, 0x44, 0x65, 0x63, 0x6f, 0x64, + 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x72, 0x65, 0x70, 0x72, 0x65, 0x73, + 0x65, 0x6e, 0x74, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x65, 0x64, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x65, + 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x20, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, 0x6f, 0x6e, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2c, 0x20, 0x62, 0x75, + 0x74, 0x0a, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x62, 0x65, 0x20, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, + 0x69, 0x7a, 0x65, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x64, 0x20, + 0x62, 0x79, 0x20, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x05, 0x01, 0x12, 0x03, 0x3c, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x00, 0x12, + 0x03, 0x3d, 0x04, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x3d, + 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3d, 0x0b, 0x0d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3d, 0x10, 0x11, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x05, 0x02, 0x01, 0x12, 0x03, 0x3e, 0x04, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x05, 0x02, 0x01, 0x05, 0x12, 0x03, 0x3e, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x01, 0x01, 0x12, 0x03, 0x3e, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x3e, 0x1d, 0x1e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x02, 0x12, 0x03, 0x3f, + 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x05, 0x12, 0x03, 0x3f, 0x04, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x01, 0x12, 0x03, 0x3f, 0x0b, 0x19, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x02, 0x03, 0x12, 0x03, 0x3f, 0x1c, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x05, 0x02, 0x03, 0x12, 0x03, 0x40, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, + 0x03, 0x04, 0x12, 0x03, 0x40, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x05, + 0x12, 0x03, 0x40, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x01, 0x12, 0x03, + 0x40, 0x14, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x03, 0x03, 0x12, 0x03, 0x40, 0x28, + 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x04, 0x12, 0x03, 0x41, 0x04, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x04, 0x05, 0x12, 0x03, 0x41, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x04, 0x01, 0x12, 0x03, 0x41, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x41, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x05, + 0x12, 0x03, 0x42, 0x04, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x05, 0x12, 0x03, + 0x42, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x01, 0x12, 0x03, 0x42, 0x0b, + 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x05, 0x03, 0x12, 0x03, 0x42, 0x1b, 0x1c, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x06, 0x12, 0x03, 0x43, 0x04, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x05, 0x02, 0x06, 0x06, 0x12, 0x03, 0x43, 0x04, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, + 0x02, 0x06, 0x01, 0x12, 0x03, 0x43, 0x1a, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x06, + 0x03, 0x12, 0x03, 0x43, 0x29, 0x2a, 0x0a, 0x2a, 0x0a, 0x04, 0x04, 0x05, 0x02, 0x07, 0x12, 0x03, + 0x44, 0x04, 0x1c, 0x22, 0x1d, 0x20, 0x65, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, + 0x65, 0x73, 0x20, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x05, 0x12, 0x03, 0x44, 0x04, 0x09, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x01, 0x12, 0x03, 0x44, 0x0a, 0x17, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x05, 0x02, 0x07, 0x03, 0x12, 0x03, 0x44, 0x1a, 0x1b, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x0a, 0xd1, 0x20, 0x0a, 0x22, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, + 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x78, 0x6d, 0x74, + 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x73, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, + 0x65, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xf7, 0x01, 0x0a, 0x10, 0x53, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, + 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x4e, 0x73, 0x12, 0x51, 0x0a, 0x09, + 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x2e, 0x53, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, + 0x6b, 0x31, 0x48, 0x00, 0x52, 0x09, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x12, + 0x45, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, + 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x1a, 0x21, 0x0a, 0x09, 0x53, 0x65, 0x63, 0x70, 0x32, 0x35, + 0x36, 0x6b, 0x31, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, + 0x6f, 0x6e, 0x22, 0xa4, 0x01, 0x0a, 0x12, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, + 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x32, 0x12, 0x4a, 0x0a, 0x0c, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x0b, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x42, 0x0a, 0x08, 0x70, 0x72, 0x65, 0x5f, 0x6b, 0x65, 0x79, + 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, + 0x52, 0x07, 0x70, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0xe4, 0x01, 0x0a, 0x0a, 0x50, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 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, 0x4b, 0x0a, 0x09, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, + 0x36, 0x6b, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x2e, 0x53, 0x65, 0x63, + 0x70, 0x32, 0x35, 0x36, 0x6b, 0x31, 0x48, 0x00, 0x52, 0x09, 0x73, 0x65, 0x63, 0x70, 0x32, 0x35, + 0x36, 0x6b, 0x31, 0x12, 0x3f, 0x0a, 0x0a, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4b, 0x65, 0x79, 0x52, 0x09, 0x70, 0x75, 0x62, 0x6c, 0x69, + 0x63, 0x4b, 0x65, 0x79, 0x1a, 0x21, 0x0a, 0x09, 0x53, 0x65, 0x63, 0x70, 0x32, 0x35, 0x36, 0x6b, + 0x31, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, 0x6f, 0x6e, + 0x22, 0x98, 0x01, 0x0a, 0x12, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, + 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x31, 0x12, 0x44, 0x0a, 0x0c, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, + 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, + 0x52, 0x0b, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x12, 0x3c, 0x0a, + 0x08, 0x70, 0x72, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, + 0x65, 0x79, 0x52, 0x07, 0x70, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x97, 0x01, 0x0a, 0x10, + 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, + 0x12, 0x3b, 0x0a, 0x02, 0x76, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x78, + 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, + 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x31, 0x48, 0x00, 0x52, 0x02, 0x76, 0x31, 0x12, 0x3b, 0x0a, + 0x02, 0x76, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x78, 0x6d, 0x74, 0x70, + 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x73, 0x2e, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, + 0x6c, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x02, 0x76, 0x32, 0x42, 0x09, 0x0a, 0x07, 0x76, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x86, 0x01, 0x0a, 0x1b, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, + 0x64, 0x6c, 0x65, 0x56, 0x31, 0x12, 0x24, 0x0a, 0x0e, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x5f, + 0x70, 0x72, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x77, + 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x50, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x41, 0x0a, 0x0a, 0x63, + 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, 0x43, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, + 0x78, 0x74, 0x52, 0x0a, 0x63, 0x69, 0x70, 0x68, 0x65, 0x72, 0x74, 0x65, 0x78, 0x74, 0x22, 0x6c, + 0x0a, 0x19, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, + 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x12, 0x44, 0x0a, 0x02, 0x76, + 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x2e, + 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, + 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x31, 0x48, 0x00, 0x52, 0x02, 0x76, + 0x31, 0x42, 0x09, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0xcb, 0x01, 0x0a, + 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x78, 0x6d, 0x74, 0x70, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x42, 0x0f, 0x50, 0x72, 0x69, 0x76, + 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x67, + 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x6d, 0x74, 0x70, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x33, 0x2f, 0x67, 0x6f, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xa2, 0x02, 0x03, 0x58, 0x4d, + 0x58, 0xaa, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xca, 0x02, 0x14, 0x58, 0x6d, 0x74, 0x70, 0x5c, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0xe2, + 0x02, 0x20, 0x58, 0x6d, 0x74, 0x70, 0x5c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x15, 0x58, 0x6d, 0x74, 0x70, 0x3a, 0x3a, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73, 0x4a, 0xc3, 0x14, 0x0a, 0x06, 0x12, + 0x04, 0x04, 0x00, 0x5e, 0x01, 0x0a, 0x99, 0x01, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x04, 0x00, 0x12, + 0x1a, 0x8e, 0x01, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x4b, 0x65, 0x79, 0x20, + 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x0a, 0x0a, 0x20, 0x46, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, + 0x69, 0x6e, 0x67, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, + 0x61, 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2c, 0x20, 0x69, 0x6e, + 0x73, 0x74, 0x65, 0x61, 0x64, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x20, 0x61, 0x20, 0x77, 0x61, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x65, 0x6e, + 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x6b, + 0x65, 0x79, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x2e, + 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x06, 0x00, 0x1e, 0x0a, 0x09, 0x0a, 0x02, 0x03, + 0x00, 0x12, 0x03, 0x08, 0x00, 0x2b, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x01, 0x12, 0x03, 0x09, 0x00, + 0x2b, 0x0a, 0x08, 0x0a, 0x01, 0x08, 0x12, 0x03, 0x0b, 0x00, 0x43, 0x0a, 0x09, 0x0a, 0x02, 0x08, + 0x0b, 0x12, 0x03, 0x0b, 0x00, 0x43, 0x0a, 0x43, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x0f, 0x00, + 0x1f, 0x01, 0x1a, 0x37, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x20, + 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x73, + 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x0f, 0x08, 0x18, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x11, 0x04, 0x1a, 0x1a, 0x1a, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x20, 0x77, 0x61, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x11, 0x04, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x11, 0x0b, 0x15, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x11, 0x18, 0x19, 0x0a, 0x1b, 0x0a, 0x04, 0x04, 0x00, + 0x08, 0x00, 0x12, 0x04, 0x13, 0x04, 0x15, 0x05, 0x1a, 0x0d, 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, + 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, 0x00, 0x01, + 0x12, 0x03, 0x13, 0x0a, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x14, + 0x08, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x06, 0x12, 0x03, 0x14, 0x08, 0x11, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x14, 0x12, 0x1b, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x14, 0x1e, 0x1f, 0x0a, 0x2e, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x17, 0x04, 0x23, 0x1a, 0x21, 0x20, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, + 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x17, 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x17, 0x14, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, + 0x03, 0x12, 0x03, 0x17, 0x21, 0x22, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, + 0x1c, 0x04, 0x1e, 0x05, 0x1a, 0x0f, 0x20, 0x45, 0x43, 0x3a, 0x20, 0x53, 0x45, 0x43, 0x50, 0x32, + 0x35, 0x36, 0x6b, 0x31, 0x0a, 0x32, 0x15, 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x1c, 0x0c, 0x15, 0x0a, 0x27, 0x0a, 0x06, 0x04, 0x00, + 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1d, 0x08, 0x18, 0x22, 0x18, 0x20, 0x44, 0x20, 0x62, 0x69, + 0x67, 0x2d, 0x65, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2c, 0x20, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, + 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x1d, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x1d, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x1d, 0x16, 0x17, 0x0a, 0x65, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x23, 0x00, 0x27, 0x01, 0x1a, + 0x59, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, + 0x6c, 0x65, 0x20, 0x77, 0x72, 0x61, 0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4b, 0x65, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x70, 0x72, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x2c, 0x0a, 0x20, 0x65, 0x6e, 0x66, 0x6f, 0x72, + 0x63, 0x65, 0x73, 0x20, 0x75, 0x73, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, + 0x01, 0x12, 0x03, 0x23, 0x08, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, + 0x24, 0x04, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x24, 0x04, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x24, 0x15, 0x21, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, 0x24, 0x24, 0x25, 0x0a, 0x38, 0x0a, + 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x26, 0x04, 0x2b, 0x1a, 0x2b, 0x20, 0x61, 0x6c, 0x6c, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x6b, + 0x65, 0x79, 0x73, 0x2c, 0x20, 0x6e, 0x65, 0x77, 0x65, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, + 0x66, 0x69, 0x72, 0x73, 0x74, 0x2c, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, + 0x12, 0x03, 0x26, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, + 0x26, 0x0d, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, 0x26, 0x1e, + 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x26, 0x29, 0x2a, 0x0a, + 0x4b, 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x2a, 0x00, 0x3a, 0x01, 0x1a, 0x3f, 0x20, 0x4c, 0x45, + 0x47, 0x41, 0x43, 0x59, 0x3a, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, + 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, + 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x20, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x74, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x2a, 0x08, 0x12, 0x0a, 0x27, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, + 0x12, 0x03, 0x2c, 0x04, 0x19, 0x1a, 0x1a, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, + 0x20, 0x6b, 0x65, 0x79, 0x20, 0x77, 0x61, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2c, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x2c, 0x0b, 0x14, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x2c, 0x17, 0x18, 0x0a, 0x1b, 0x0a, 0x04, 0x04, + 0x02, 0x08, 0x00, 0x12, 0x04, 0x2e, 0x04, 0x30, 0x05, 0x1a, 0x0d, 0x20, 0x70, 0x72, 0x69, 0x76, + 0x61, 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x08, 0x00, + 0x01, 0x12, 0x03, 0x2e, 0x0a, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x2f, 0x08, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x06, 0x12, 0x03, 0x2f, 0x08, + 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2f, 0x12, 0x1b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x2f, 0x1e, 0x1f, 0x0a, 0x2e, 0x0a, + 0x04, 0x04, 0x02, 0x02, 0x02, 0x12, 0x03, 0x32, 0x04, 0x1d, 0x1a, 0x21, 0x20, 0x70, 0x75, 0x62, + 0x6c, 0x69, 0x63, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x20, 0x6b, 0x65, 0x79, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x02, 0x06, 0x12, 0x03, 0x32, 0x04, 0x0d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x02, 0x01, 0x12, 0x03, 0x32, 0x0e, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x02, 0x03, 0x12, 0x03, 0x32, 0x1b, 0x1c, 0x0a, 0x34, 0x0a, 0x04, 0x04, 0x02, 0x03, 0x00, 0x12, + 0x04, 0x37, 0x04, 0x39, 0x05, 0x1a, 0x0f, 0x20, 0x45, 0x43, 0x3a, 0x20, 0x53, 0x45, 0x43, 0x50, + 0x32, 0x35, 0x36, 0x6b, 0x31, 0x0a, 0x32, 0x15, 0x20, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, + 0x65, 0x64, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x03, 0x00, 0x01, 0x12, 0x03, 0x37, 0x0c, 0x15, 0x0a, 0x27, 0x0a, 0x06, 0x04, + 0x02, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, 0x38, 0x08, 0x18, 0x22, 0x18, 0x20, 0x44, 0x20, 0x62, + 0x69, 0x67, 0x2d, 0x65, 0x6e, 0x64, 0x69, 0x61, 0x6e, 0x2c, 0x20, 0x33, 0x32, 0x20, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, + 0x03, 0x38, 0x08, 0x0d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x38, 0x0e, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x02, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x38, 0x16, 0x17, 0x0a, 0x4e, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x3d, 0x00, 0x41, 0x01, + 0x1a, 0x42, 0x20, 0x4c, 0x45, 0x47, 0x41, 0x43, 0x59, 0x3a, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, + 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x56, 0x31, 0x20, 0x77, 0x72, + 0x61, 0x70, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x4b, 0x65, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x4b, + 0x65, 0x79, 0x73, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x3d, 0x08, 0x1a, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x3e, 0x04, 0x20, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x3e, 0x04, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3e, 0x0f, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x3e, 0x1e, 0x1f, 0x0a, 0x38, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, + 0x03, 0x40, 0x04, 0x25, 0x1a, 0x2b, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x73, 0x2c, 0x20, 0x6e, + 0x65, 0x77, 0x65, 0x72, 0x20, 0x6b, 0x65, 0x79, 0x73, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x2c, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x04, 0x12, 0x03, 0x40, 0x04, 0x0c, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x40, 0x0d, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, 0x03, 0x40, 0x18, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x01, 0x03, 0x12, 0x03, 0x40, 0x23, 0x24, 0x0a, 0x28, 0x0a, 0x02, 0x04, 0x04, 0x12, + 0x04, 0x46, 0x00, 0x4b, 0x01, 0x1a, 0x1c, 0x20, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, + 0x64, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, + 0x6c, 0x65, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x46, 0x08, 0x18, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x47, 0x04, 0x4a, 0x05, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x47, 0x0a, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x00, 0x12, 0x03, 0x48, 0x08, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, + 0x06, 0x12, 0x03, 0x48, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x48, 0x1b, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x03, 0x12, 0x03, 0x48, + 0x20, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x01, 0x12, 0x03, 0x49, 0x08, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x06, 0x12, 0x03, 0x49, 0x08, 0x1a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x49, 0x1b, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x01, 0x03, 0x12, 0x03, 0x49, 0x20, 0x21, 0x0a, 0xa1, 0x02, 0x0a, 0x02, 0x04, 0x05, + 0x12, 0x04, 0x52, 0x00, 0x57, 0x01, 0x1a, 0x94, 0x02, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, + 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, + 0x70, 0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x6b, 0x65, 0x79, 0x20, 0x6d, 0x61, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, + 0x20, 0x62, 0x79, 0x0a, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x72, + 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x6c, 0x79, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, + 0x64, 0x20, 0x22, 0x70, 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x22, 0x20, 0x77, 0x69, 0x74, 0x68, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x75, 0x73, 0x65, 0x72, 0x27, 0x73, 0x20, 0x77, 0x61, 0x6c, 0x6c, + 0x65, 0x74, 0x2c, 0x0a, 0x20, 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x45, 0x49, 0x50, 0x2d, 0x31, 0x39, + 0x31, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x61, + 0x20, 0x22, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x20, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x22, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x77, 0x69, 0x74, + 0x68, 0x0a, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x72, 0x65, 0x2d, 0x6b, 0x65, 0x79, 0x20, 0x65, + 0x6d, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x20, + 0x28, 0x73, 0x65, 0x65, 0x20, 0x78, 0x6d, 0x74, 0x70, 0x2d, 0x6a, 0x73, 0x3a, 0x3a, 0x50, 0x72, + 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, 0x2e, 0x74, + 0x6f, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x29, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x05, 0x01, 0x12, 0x03, 0x52, 0x08, 0x23, 0x0a, 0x36, 0x0a, 0x04, 0x04, 0x05, 0x02, + 0x00, 0x12, 0x03, 0x54, 0x04, 0x1d, 0x1a, 0x1d, 0x20, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x6c, + 0x79, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x70, 0x72, 0x65, 0x2d, + 0x6b, 0x65, 0x79, 0x20, 0x0a, 0x22, 0x0a, 0x20, 0x33, 0x32, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x05, 0x12, 0x03, 0x54, 0x04, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x00, 0x01, 0x12, 0x03, 0x54, 0x0a, 0x18, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x05, 0x02, 0x00, 0x03, 0x12, 0x03, 0x54, 0x1b, 0x1c, 0x0a, 0x36, 0x0a, 0x04, 0x04, + 0x05, 0x02, 0x01, 0x12, 0x03, 0x56, 0x04, 0x1e, 0x1a, 0x29, 0x20, 0x4d, 0x55, 0x53, 0x54, 0x20, + 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, + 0x64, 0x20, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, + 0x6c, 0x65, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x06, 0x12, 0x03, 0x56, 0x04, + 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x01, 0x12, 0x03, 0x56, 0x0f, 0x19, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x05, 0x02, 0x01, 0x03, 0x12, 0x03, 0x56, 0x1c, 0x1d, 0x0a, 0x32, 0x0a, + 0x02, 0x04, 0x06, 0x12, 0x04, 0x5a, 0x00, 0x5e, 0x01, 0x1a, 0x26, 0x20, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x20, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x20, + 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x42, 0x75, 0x6e, 0x64, 0x6c, 0x65, + 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x06, 0x01, 0x12, 0x03, 0x5a, 0x08, 0x21, 0x0a, 0x0c, 0x0a, + 0x04, 0x04, 0x06, 0x08, 0x00, 0x12, 0x04, 0x5b, 0x04, 0x5d, 0x05, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x06, 0x08, 0x00, 0x01, 0x12, 0x03, 0x5b, 0x0a, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x06, 0x02, + 0x00, 0x12, 0x03, 0x5c, 0x08, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x5c, 0x08, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x01, 0x12, 0x03, 0x5c, + 0x24, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x06, 0x02, 0x00, 0x03, 0x12, 0x03, 0x5c, 0x29, 0x2a, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +]; +include!("xmtp.message_contents.serde.rs"); +// @@protoc_insertion_point(module) \ No newline at end of file diff --git a/crates/xmtp-proto/src/gen/xmtp.message_contents.serde.rs b/crates/xmtp-proto/src/gen/xmtp.message_contents.serde.rs new file mode 100644 index 000000000..c4aebd0d2 --- /dev/null +++ b/crates/xmtp-proto/src/gen/xmtp.message_contents.serde.rs @@ -0,0 +1,5198 @@ +// @generated +impl serde::Serialize for Ciphertext { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Ciphertext", len)?; + if let Some(v) = self.union.as_ref() { + match v { + ciphertext::Union::Aes256GcmHkdfSha256(v) => { + struct_ser.serialize_field("aes256GcmHkdfSha256", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Ciphertext { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "aes256_gcm_hkdf_sha256", + "aes256GcmHkdfSha256", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Aes256GcmHkdfSha256, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "aes256GcmHkdfSha256" | "aes256_gcm_hkdf_sha256" => Ok(GeneratedField::Aes256GcmHkdfSha256), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Ciphertext; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Ciphertext") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Aes256GcmHkdfSha256 => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("aes256GcmHkdfSha256")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(ciphertext::Union::Aes256GcmHkdfSha256) +; + } + } + } + Ok(Ciphertext { + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Ciphertext", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ciphertext::Aes256gcmHkdfsha256 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.hkdf_salt.is_empty() { + len += 1; + } + if !self.gcm_nonce.is_empty() { + len += 1; + } + if !self.payload.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Ciphertext.Aes256gcmHkdfsha256", len)?; + if !self.hkdf_salt.is_empty() { + struct_ser.serialize_field("hkdfSalt", pbjson::private::base64::encode(&self.hkdf_salt).as_str())?; + } + if !self.gcm_nonce.is_empty() { + struct_ser.serialize_field("gcmNonce", pbjson::private::base64::encode(&self.gcm_nonce).as_str())?; + } + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ciphertext::Aes256gcmHkdfsha256 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "hkdf_salt", + "hkdfSalt", + "gcm_nonce", + "gcmNonce", + "payload", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HkdfSalt, + GcmNonce, + Payload, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "hkdfSalt" | "hkdf_salt" => Ok(GeneratedField::HkdfSalt), + "gcmNonce" | "gcm_nonce" => Ok(GeneratedField::GcmNonce), + "payload" => Ok(GeneratedField::Payload), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ciphertext::Aes256gcmHkdfsha256; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Ciphertext.Aes256gcmHkdfsha256") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut hkdf_salt__ = None; + let mut gcm_nonce__ = None; + let mut payload__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HkdfSalt => { + if hkdf_salt__.is_some() { + return Err(serde::de::Error::duplicate_field("hkdfSalt")); + } + hkdf_salt__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::GcmNonce => { + if gcm_nonce__.is_some() { + return Err(serde::de::Error::duplicate_field("gcmNonce")); + } + gcm_nonce__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(ciphertext::Aes256gcmHkdfsha256 { + hkdf_salt: hkdf_salt__.unwrap_or_default(), + gcm_nonce: gcm_nonce__.unwrap_or_default(), + payload: payload__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Ciphertext.Aes256gcmHkdfsha256", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Composite { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.parts.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Composite", len)?; + if !self.parts.is_empty() { + struct_ser.serialize_field("parts", &self.parts)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Composite { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "parts", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Parts, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "parts" => Ok(GeneratedField::Parts), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Composite; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Composite") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut parts__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Parts => { + if parts__.is_some() { + return Err(serde::de::Error::duplicate_field("parts")); + } + parts__ = Some(map.next_value()?); + } + } + } + Ok(Composite { + parts: parts__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Composite", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for composite::Part { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.element.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Composite.Part", len)?; + if let Some(v) = self.element.as_ref() { + match v { + composite::part::Element::Part(v) => { + struct_ser.serialize_field("part", v)?; + } + composite::part::Element::Composite(v) => { + struct_ser.serialize_field("composite", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for composite::Part { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "part", + "composite", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Part, + Composite, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "part" => Ok(GeneratedField::Part), + "composite" => Ok(GeneratedField::Composite), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = composite::Part; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Composite.Part") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut element__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Part => { + if element__.is_some() { + return Err(serde::de::Error::duplicate_field("part")); + } + element__ = map.next_value::<::std::option::Option<_>>()?.map(composite::part::Element::Part) +; + } + GeneratedField::Composite => { + if element__.is_some() { + return Err(serde::de::Error::duplicate_field("composite")); + } + element__ = map.next_value::<::std::option::Option<_>>()?.map(composite::part::Element::Composite) +; + } + } + } + Ok(composite::Part { + element: element__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Composite.Part", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Compression { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + let variant = match self { + Self::Deflate => "COMPRESSION_DEFLATE", + Self::Gzip => "COMPRESSION_GZIP", + }; + serializer.serialize_str(variant) + } +} +impl<'de> serde::Deserialize<'de> for Compression { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "COMPRESSION_DEFLATE", + "COMPRESSION_GZIP", + ]; + + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Compression; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + fn visit_i64(self, v: i64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(Compression::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) + }) + } + + fn visit_u64(self, v: u64) -> std::result::Result + where + E: serde::de::Error, + { + use std::convert::TryFrom; + i32::try_from(v) + .ok() + .and_then(Compression::from_i32) + .ok_or_else(|| { + serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) + }) + } + + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "COMPRESSION_DEFLATE" => Ok(Compression::Deflate), + "COMPRESSION_GZIP" => Ok(Compression::Gzip), + _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), + } + } + } + deserializer.deserialize_any(GeneratedVisitor) + } +} +impl serde::Serialize for ContactBundle { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.ContactBundle", len)?; + if let Some(v) = self.version.as_ref() { + match v { + contact_bundle::Version::V1(v) => { + struct_ser.serialize_field("v1", v)?; + } + contact_bundle::Version::V2(v) => { + struct_ser.serialize_field("v2", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ContactBundle { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "v1", + "v2", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + V1, + V2, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "v1" => Ok(GeneratedField::V1), + "v2" => Ok(GeneratedField::V2), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ContactBundle; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.ContactBundle") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::V1 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v1")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(contact_bundle::Version::V1) +; + } + GeneratedField::V2 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v2")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(contact_bundle::Version::V2) +; + } + } + } + Ok(ContactBundle { + version: version__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.ContactBundle", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ContactBundleV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.key_bundle.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.ContactBundleV1", len)?; + if let Some(v) = self.key_bundle.as_ref() { + struct_ser.serialize_field("keyBundle", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ContactBundleV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_bundle", + "keyBundle", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyBundle, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyBundle" | "key_bundle" => Ok(GeneratedField::KeyBundle), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ContactBundleV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.ContactBundleV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_bundle__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::KeyBundle => { + if key_bundle__.is_some() { + return Err(serde::de::Error::duplicate_field("keyBundle")); + } + key_bundle__ = map.next_value()?; + } + } + } + Ok(ContactBundleV1 { + key_bundle: key_bundle__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.ContactBundleV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ContactBundleV2 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.key_bundle.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.ContactBundleV2", len)?; + if let Some(v) = self.key_bundle.as_ref() { + struct_ser.serialize_field("keyBundle", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ContactBundleV2 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_bundle", + "keyBundle", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyBundle, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyBundle" | "key_bundle" => Ok(GeneratedField::KeyBundle), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ContactBundleV2; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.ContactBundleV2") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_bundle__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::KeyBundle => { + if key_bundle__.is_some() { + return Err(serde::de::Error::duplicate_field("keyBundle")); + } + key_bundle__ = map.next_value()?; + } + } + } + Ok(ContactBundleV2 { + key_bundle: key_bundle__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.ContactBundleV2", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ContentTypeId { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.authority_id.is_empty() { + len += 1; + } + if !self.type_id.is_empty() { + len += 1; + } + if self.version_major != 0 { + len += 1; + } + if self.version_minor != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.ContentTypeId", len)?; + if !self.authority_id.is_empty() { + struct_ser.serialize_field("authorityId", &self.authority_id)?; + } + if !self.type_id.is_empty() { + struct_ser.serialize_field("typeId", &self.type_id)?; + } + if self.version_major != 0 { + struct_ser.serialize_field("versionMajor", &self.version_major)?; + } + if self.version_minor != 0 { + struct_ser.serialize_field("versionMinor", &self.version_minor)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ContentTypeId { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "authority_id", + "authorityId", + "type_id", + "typeId", + "version_major", + "versionMajor", + "version_minor", + "versionMinor", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + AuthorityId, + TypeId, + VersionMajor, + VersionMinor, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "authorityId" | "authority_id" => Ok(GeneratedField::AuthorityId), + "typeId" | "type_id" => Ok(GeneratedField::TypeId), + "versionMajor" | "version_major" => Ok(GeneratedField::VersionMajor), + "versionMinor" | "version_minor" => Ok(GeneratedField::VersionMinor), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ContentTypeId; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.ContentTypeId") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut authority_id__ = None; + let mut type_id__ = None; + let mut version_major__ = None; + let mut version_minor__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::AuthorityId => { + if authority_id__.is_some() { + return Err(serde::de::Error::duplicate_field("authorityId")); + } + authority_id__ = Some(map.next_value()?); + } + GeneratedField::TypeId => { + if type_id__.is_some() { + return Err(serde::de::Error::duplicate_field("typeId")); + } + type_id__ = Some(map.next_value()?); + } + GeneratedField::VersionMajor => { + if version_major__.is_some() { + return Err(serde::de::Error::duplicate_field("versionMajor")); + } + version_major__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::VersionMinor => { + if version_minor__.is_some() { + return Err(serde::de::Error::duplicate_field("versionMinor")); + } + version_minor__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(ContentTypeId { + authority_id: authority_id__.unwrap_or_default(), + type_id: type_id__.unwrap_or_default(), + version_major: version_major__.unwrap_or_default(), + version_minor: version_minor__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.ContentTypeId", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for ConversationReference { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.topic.is_empty() { + len += 1; + } + if !self.peer_address.is_empty() { + len += 1; + } + if self.created_ns != 0 { + len += 1; + } + if self.context.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.ConversationReference", len)?; + if !self.topic.is_empty() { + struct_ser.serialize_field("topic", &self.topic)?; + } + if !self.peer_address.is_empty() { + struct_ser.serialize_field("peerAddress", &self.peer_address)?; + } + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + if let Some(v) = self.context.as_ref() { + struct_ser.serialize_field("context", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for ConversationReference { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "topic", + "peer_address", + "peerAddress", + "created_ns", + "createdNs", + "context", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Topic, + PeerAddress, + CreatedNs, + Context, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "topic" => Ok(GeneratedField::Topic), + "peerAddress" | "peer_address" => Ok(GeneratedField::PeerAddress), + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + "context" => Ok(GeneratedField::Context), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = ConversationReference; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.ConversationReference") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut topic__ = None; + let mut peer_address__ = None; + let mut created_ns__ = None; + let mut context__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Topic => { + if topic__.is_some() { + return Err(serde::de::Error::duplicate_field("topic")); + } + topic__ = Some(map.next_value()?); + } + GeneratedField::PeerAddress => { + if peer_address__.is_some() { + return Err(serde::de::Error::duplicate_field("peerAddress")); + } + peer_address__ = Some(map.next_value()?); + } + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Context => { + if context__.is_some() { + return Err(serde::de::Error::duplicate_field("context")); + } + context__ = map.next_value()?; + } + } + } + Ok(ConversationReference { + topic: topic__.unwrap_or_default(), + peer_address: peer_address__.unwrap_or_default(), + created_ns: created_ns__.unwrap_or_default(), + context: context__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.ConversationReference", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for DecodedMessage { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.id.is_empty() { + len += 1; + } + if !self.message_version.is_empty() { + len += 1; + } + if !self.sender_address.is_empty() { + len += 1; + } + if self.recipient_address.is_some() { + len += 1; + } + if self.sent_ns != 0 { + len += 1; + } + if !self.content_topic.is_empty() { + len += 1; + } + if self.conversation.is_some() { + len += 1; + } + if !self.content_bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.DecodedMessage", len)?; + if !self.id.is_empty() { + struct_ser.serialize_field("id", &self.id)?; + } + if !self.message_version.is_empty() { + struct_ser.serialize_field("messageVersion", &self.message_version)?; + } + if !self.sender_address.is_empty() { + struct_ser.serialize_field("senderAddress", &self.sender_address)?; + } + if let Some(v) = self.recipient_address.as_ref() { + struct_ser.serialize_field("recipientAddress", v)?; + } + if self.sent_ns != 0 { + struct_ser.serialize_field("sentNs", ToString::to_string(&self.sent_ns).as_str())?; + } + if !self.content_topic.is_empty() { + struct_ser.serialize_field("contentTopic", &self.content_topic)?; + } + if let Some(v) = self.conversation.as_ref() { + struct_ser.serialize_field("conversation", v)?; + } + if !self.content_bytes.is_empty() { + struct_ser.serialize_field("contentBytes", pbjson::private::base64::encode(&self.content_bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for DecodedMessage { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "id", + "message_version", + "messageVersion", + "sender_address", + "senderAddress", + "recipient_address", + "recipientAddress", + "sent_ns", + "sentNs", + "content_topic", + "contentTopic", + "conversation", + "content_bytes", + "contentBytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Id, + MessageVersion, + SenderAddress, + RecipientAddress, + SentNs, + ContentTopic, + Conversation, + ContentBytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "id" => Ok(GeneratedField::Id), + "messageVersion" | "message_version" => Ok(GeneratedField::MessageVersion), + "senderAddress" | "sender_address" => Ok(GeneratedField::SenderAddress), + "recipientAddress" | "recipient_address" => Ok(GeneratedField::RecipientAddress), + "sentNs" | "sent_ns" => Ok(GeneratedField::SentNs), + "contentTopic" | "content_topic" => Ok(GeneratedField::ContentTopic), + "conversation" => Ok(GeneratedField::Conversation), + "contentBytes" | "content_bytes" => Ok(GeneratedField::ContentBytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = DecodedMessage; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.DecodedMessage") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut id__ = None; + let mut message_version__ = None; + let mut sender_address__ = None; + let mut recipient_address__ = None; + let mut sent_ns__ = None; + let mut content_topic__ = None; + let mut conversation__ = None; + let mut content_bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Id => { + if id__.is_some() { + return Err(serde::de::Error::duplicate_field("id")); + } + id__ = Some(map.next_value()?); + } + GeneratedField::MessageVersion => { + if message_version__.is_some() { + return Err(serde::de::Error::duplicate_field("messageVersion")); + } + message_version__ = Some(map.next_value()?); + } + GeneratedField::SenderAddress => { + if sender_address__.is_some() { + return Err(serde::de::Error::duplicate_field("senderAddress")); + } + sender_address__ = Some(map.next_value()?); + } + GeneratedField::RecipientAddress => { + if recipient_address__.is_some() { + return Err(serde::de::Error::duplicate_field("recipientAddress")); + } + recipient_address__ = map.next_value()?; + } + GeneratedField::SentNs => { + if sent_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("sentNs")); + } + sent_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::ContentTopic => { + if content_topic__.is_some() { + return Err(serde::de::Error::duplicate_field("contentTopic")); + } + content_topic__ = Some(map.next_value()?); + } + GeneratedField::Conversation => { + if conversation__.is_some() { + return Err(serde::de::Error::duplicate_field("conversation")); + } + conversation__ = map.next_value()?; + } + GeneratedField::ContentBytes => { + if content_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("contentBytes")); + } + content_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(DecodedMessage { + id: id__.unwrap_or_default(), + message_version: message_version__.unwrap_or_default(), + sender_address: sender_address__.unwrap_or_default(), + recipient_address: recipient_address__, + sent_ns: sent_ns__.unwrap_or_default(), + content_topic: content_topic__.unwrap_or_default(), + conversation: conversation__, + content_bytes: content_bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.DecodedMessage", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncodedContent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.r#type.is_some() { + len += 1; + } + if !self.parameters.is_empty() { + len += 1; + } + if self.fallback.is_some() { + len += 1; + } + if self.compression.is_some() { + len += 1; + } + if !self.content.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.EncodedContent", len)?; + if let Some(v) = self.r#type.as_ref() { + struct_ser.serialize_field("type", v)?; + } + if !self.parameters.is_empty() { + struct_ser.serialize_field("parameters", &self.parameters)?; + } + if let Some(v) = self.fallback.as_ref() { + struct_ser.serialize_field("fallback", v)?; + } + if let Some(v) = self.compression.as_ref() { + let v = Compression::from_i32(*v) + .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; + struct_ser.serialize_field("compression", &v)?; + } + if !self.content.is_empty() { + struct_ser.serialize_field("content", pbjson::private::base64::encode(&self.content).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncodedContent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "type", + "parameters", + "fallback", + "compression", + "content", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Type, + Parameters, + Fallback, + Compression, + Content, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "type" => Ok(GeneratedField::Type), + "parameters" => Ok(GeneratedField::Parameters), + "fallback" => Ok(GeneratedField::Fallback), + "compression" => Ok(GeneratedField::Compression), + "content" => Ok(GeneratedField::Content), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncodedContent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.EncodedContent") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut r#type__ = None; + let mut parameters__ = None; + let mut fallback__ = None; + let mut compression__ = None; + let mut content__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Type => { + if r#type__.is_some() { + return Err(serde::de::Error::duplicate_field("type")); + } + r#type__ = map.next_value()?; + } + GeneratedField::Parameters => { + if parameters__.is_some() { + return Err(serde::de::Error::duplicate_field("parameters")); + } + parameters__ = Some( + map.next_value::>()? + ); + } + GeneratedField::Fallback => { + if fallback__.is_some() { + return Err(serde::de::Error::duplicate_field("fallback")); + } + fallback__ = map.next_value()?; + } + GeneratedField::Compression => { + if compression__.is_some() { + return Err(serde::de::Error::duplicate_field("compression")); + } + compression__ = map.next_value::<::std::option::Option>()?.map(|x| x as i32); + } + GeneratedField::Content => { + if content__.is_some() { + return Err(serde::de::Error::duplicate_field("content")); + } + content__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(EncodedContent { + r#type: r#type__, + parameters: parameters__.unwrap_or_default(), + fallback: fallback__, + compression: compression__, + content: content__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.EncodedContent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncryptedPrivateKeyBundle { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.EncryptedPrivateKeyBundle", len)?; + if let Some(v) = self.version.as_ref() { + match v { + encrypted_private_key_bundle::Version::V1(v) => { + struct_ser.serialize_field("v1", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncryptedPrivateKeyBundle { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "v1", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + V1, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "v1" => Ok(GeneratedField::V1), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncryptedPrivateKeyBundle; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.EncryptedPrivateKeyBundle") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::V1 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v1")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(encrypted_private_key_bundle::Version::V1) +; + } + } + } + Ok(EncryptedPrivateKeyBundle { + version: version__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.EncryptedPrivateKeyBundle", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for EncryptedPrivateKeyBundleV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.wallet_pre_key.is_empty() { + len += 1; + } + if self.ciphertext.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.EncryptedPrivateKeyBundleV1", len)?; + if !self.wallet_pre_key.is_empty() { + struct_ser.serialize_field("walletPreKey", pbjson::private::base64::encode(&self.wallet_pre_key).as_str())?; + } + if let Some(v) = self.ciphertext.as_ref() { + struct_ser.serialize_field("ciphertext", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for EncryptedPrivateKeyBundleV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "wallet_pre_key", + "walletPreKey", + "ciphertext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + WalletPreKey, + Ciphertext, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "walletPreKey" | "wallet_pre_key" => Ok(GeneratedField::WalletPreKey), + "ciphertext" => Ok(GeneratedField::Ciphertext), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = EncryptedPrivateKeyBundleV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.EncryptedPrivateKeyBundleV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut wallet_pre_key__ = None; + let mut ciphertext__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::WalletPreKey => { + if wallet_pre_key__.is_some() { + return Err(serde::de::Error::duplicate_field("walletPreKey")); + } + wallet_pre_key__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Ciphertext => { + if ciphertext__.is_some() { + return Err(serde::de::Error::duplicate_field("ciphertext")); + } + ciphertext__ = map.next_value()?; + } + } + } + Ok(EncryptedPrivateKeyBundleV1 { + wallet_pre_key: wallet_pre_key__.unwrap_or_default(), + ciphertext: ciphertext__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.EncryptedPrivateKeyBundleV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for InvitationV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.topic.is_empty() { + len += 1; + } + if self.context.is_some() { + len += 1; + } + if self.encryption.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.InvitationV1", len)?; + if !self.topic.is_empty() { + struct_ser.serialize_field("topic", &self.topic)?; + } + if let Some(v) = self.context.as_ref() { + struct_ser.serialize_field("context", v)?; + } + if let Some(v) = self.encryption.as_ref() { + match v { + invitation_v1::Encryption::Aes256GcmHkdfSha256(v) => { + struct_ser.serialize_field("aes256GcmHkdfSha256", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for InvitationV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "topic", + "context", + "aes256_gcm_hkdf_sha256", + "aes256GcmHkdfSha256", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Topic, + Context, + Aes256GcmHkdfSha256, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "topic" => Ok(GeneratedField::Topic), + "context" => Ok(GeneratedField::Context), + "aes256GcmHkdfSha256" | "aes256_gcm_hkdf_sha256" => Ok(GeneratedField::Aes256GcmHkdfSha256), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = InvitationV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.InvitationV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut topic__ = None; + let mut context__ = None; + let mut encryption__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Topic => { + if topic__.is_some() { + return Err(serde::de::Error::duplicate_field("topic")); + } + topic__ = Some(map.next_value()?); + } + GeneratedField::Context => { + if context__.is_some() { + return Err(serde::de::Error::duplicate_field("context")); + } + context__ = map.next_value()?; + } + GeneratedField::Aes256GcmHkdfSha256 => { + if encryption__.is_some() { + return Err(serde::de::Error::duplicate_field("aes256GcmHkdfSha256")); + } + encryption__ = map.next_value::<::std::option::Option<_>>()?.map(invitation_v1::Encryption::Aes256GcmHkdfSha256) +; + } + } + } + Ok(InvitationV1 { + topic: topic__.unwrap_or_default(), + context: context__, + encryption: encryption__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.InvitationV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for invitation_v1::Aes256gcmHkdfsha256 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key_material.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256", len)?; + if !self.key_material.is_empty() { + struct_ser.serialize_field("keyMaterial", pbjson::private::base64::encode(&self.key_material).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for invitation_v1::Aes256gcmHkdfsha256 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_material", + "keyMaterial", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyMaterial, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyMaterial" | "key_material" => Ok(GeneratedField::KeyMaterial), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = invitation_v1::Aes256gcmHkdfsha256; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_material__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::KeyMaterial => { + if key_material__.is_some() { + return Err(serde::de::Error::duplicate_field("keyMaterial")); + } + key_material__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(invitation_v1::Aes256gcmHkdfsha256 { + key_material: key_material__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.InvitationV1.Aes256gcmHkdfsha256", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for invitation_v1::Context { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.conversation_id.is_empty() { + len += 1; + } + if !self.metadata.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.InvitationV1.Context", len)?; + if !self.conversation_id.is_empty() { + struct_ser.serialize_field("conversationId", &self.conversation_id)?; + } + if !self.metadata.is_empty() { + struct_ser.serialize_field("metadata", &self.metadata)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for invitation_v1::Context { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "conversation_id", + "conversationId", + "metadata", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + ConversationId, + Metadata, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "conversationId" | "conversation_id" => Ok(GeneratedField::ConversationId), + "metadata" => Ok(GeneratedField::Metadata), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = invitation_v1::Context; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.InvitationV1.Context") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut conversation_id__ = None; + let mut metadata__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::ConversationId => { + if conversation_id__.is_some() { + return Err(serde::de::Error::duplicate_field("conversationId")); + } + conversation_id__ = Some(map.next_value()?); + } + GeneratedField::Metadata => { + if metadata__.is_some() { + return Err(serde::de::Error::duplicate_field("metadata")); + } + metadata__ = Some( + map.next_value::>()? + ); + } + } + } + Ok(invitation_v1::Context { + conversation_id: conversation_id__.unwrap_or_default(), + metadata: metadata__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.InvitationV1.Context", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Message { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Message", len)?; + if let Some(v) = self.version.as_ref() { + match v { + message::Version::V1(v) => { + struct_ser.serialize_field("v1", v)?; + } + message::Version::V2(v) => { + struct_ser.serialize_field("v2", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Message { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "v1", + "v2", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + V1, + V2, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "v1" => Ok(GeneratedField::V1), + "v2" => Ok(GeneratedField::V2), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Message; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Message") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::V1 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v1")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(message::Version::V1) +; + } + GeneratedField::V2 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v2")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(message::Version::V2) +; + } + } + } + Ok(Message { + version: version__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Message", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MessageHeaderV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.sender.is_some() { + len += 1; + } + if self.recipient.is_some() { + len += 1; + } + if self.timestamp != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.MessageHeaderV1", len)?; + if let Some(v) = self.sender.as_ref() { + struct_ser.serialize_field("sender", v)?; + } + if let Some(v) = self.recipient.as_ref() { + struct_ser.serialize_field("recipient", v)?; + } + if self.timestamp != 0 { + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MessageHeaderV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sender", + "recipient", + "timestamp", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sender, + Recipient, + Timestamp, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sender" => Ok(GeneratedField::Sender), + "recipient" => Ok(GeneratedField::Recipient), + "timestamp" => Ok(GeneratedField::Timestamp), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MessageHeaderV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.MessageHeaderV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sender__ = None; + let mut recipient__ = None; + let mut timestamp__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = map.next_value()?; + } + GeneratedField::Recipient => { + if recipient__.is_some() { + return Err(serde::de::Error::duplicate_field("recipient")); + } + recipient__ = map.next_value()?; + } + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); + } + timestamp__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(MessageHeaderV1 { + sender: sender__, + recipient: recipient__, + timestamp: timestamp__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.MessageHeaderV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MessageHeaderV2 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_ns != 0 { + len += 1; + } + if !self.topic.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.MessageHeaderV2", len)?; + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + if !self.topic.is_empty() { + struct_ser.serialize_field("topic", &self.topic)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MessageHeaderV2 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_ns", + "createdNs", + "topic", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedNs, + Topic, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + "topic" => Ok(GeneratedField::Topic), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MessageHeaderV2; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.MessageHeaderV2") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_ns__ = None; + let mut topic__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Topic => { + if topic__.is_some() { + return Err(serde::de::Error::duplicate_field("topic")); + } + topic__ = Some(map.next_value()?); + } + } + } + Ok(MessageHeaderV2 { + created_ns: created_ns__.unwrap_or_default(), + topic: topic__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.MessageHeaderV2", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MessageV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.header_bytes.is_empty() { + len += 1; + } + if self.ciphertext.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.MessageV1", len)?; + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if let Some(v) = self.ciphertext.as_ref() { + struct_ser.serialize_field("ciphertext", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MessageV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "header_bytes", + "headerBytes", + "ciphertext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HeaderBytes, + Ciphertext, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "ciphertext" => Ok(GeneratedField::Ciphertext), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MessageV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.MessageV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut header_bytes__ = None; + let mut ciphertext__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Ciphertext => { + if ciphertext__.is_some() { + return Err(serde::de::Error::duplicate_field("ciphertext")); + } + ciphertext__ = map.next_value()?; + } + } + } + Ok(MessageV1 { + header_bytes: header_bytes__.unwrap_or_default(), + ciphertext: ciphertext__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.MessageV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for MessageV2 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.header_bytes.is_empty() { + len += 1; + } + if self.ciphertext.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.MessageV2", len)?; + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if let Some(v) = self.ciphertext.as_ref() { + struct_ser.serialize_field("ciphertext", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for MessageV2 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "header_bytes", + "headerBytes", + "ciphertext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HeaderBytes, + Ciphertext, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "ciphertext" => Ok(GeneratedField::Ciphertext), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = MessageV2; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.MessageV2") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut header_bytes__ = None; + let mut ciphertext__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Ciphertext => { + if ciphertext__.is_some() { + return Err(serde::de::Error::duplicate_field("ciphertext")); + } + ciphertext__ = map.next_value()?; + } + } + } + Ok(MessageV2 { + header_bytes: header_bytes__.unwrap_or_default(), + ciphertext: ciphertext__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.MessageV2", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PrivateKey { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.timestamp != 0 { + len += 1; + } + if self.public_key.is_some() { + len += 1; + } + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PrivateKey", len)?; + if self.timestamp != 0 { + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; + } + if let Some(v) = self.public_key.as_ref() { + struct_ser.serialize_field("publicKey", v)?; + } + if let Some(v) = self.union.as_ref() { + match v { + private_key::Union::Secp256k1(v) => { + struct_ser.serialize_field("secp256k1", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PrivateKey { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timestamp", + "public_key", + "publicKey", + "secp256k1", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timestamp, + PublicKey, + Secp256k1, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timestamp" => Ok(GeneratedField::Timestamp), + "publicKey" | "public_key" => Ok(GeneratedField::PublicKey), + "secp256k1" => Ok(GeneratedField::Secp256k1), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrivateKey; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PrivateKey") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timestamp__ = None; + let mut public_key__ = None; + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); + } + timestamp__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PublicKey => { + if public_key__.is_some() { + return Err(serde::de::Error::duplicate_field("publicKey")); + } + public_key__ = map.next_value()?; + } + GeneratedField::Secp256k1 => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("secp256k1")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(private_key::Union::Secp256k1) +; + } + } + } + Ok(PrivateKey { + timestamp: timestamp__.unwrap_or_default(), + public_key: public_key__, + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PrivateKey", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for private_key::Secp256k1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PrivateKey.Secp256k1", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for private_key::Secp256k1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = private_key::Secp256k1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PrivateKey.Secp256k1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(private_key::Secp256k1 { + bytes: bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PrivateKey.Secp256k1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PrivateKeyBundle { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PrivateKeyBundle", len)?; + if let Some(v) = self.version.as_ref() { + match v { + private_key_bundle::Version::V1(v) => { + struct_ser.serialize_field("v1", v)?; + } + private_key_bundle::Version::V2(v) => { + struct_ser.serialize_field("v2", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PrivateKeyBundle { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "v1", + "v2", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + V1, + V2, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "v1" => Ok(GeneratedField::V1), + "v2" => Ok(GeneratedField::V2), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrivateKeyBundle; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PrivateKeyBundle") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::V1 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v1")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(private_key_bundle::Version::V1) +; + } + GeneratedField::V2 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v2")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(private_key_bundle::Version::V2) +; + } + } + } + Ok(PrivateKeyBundle { + version: version__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PrivateKeyBundle", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PrivateKeyBundleV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.identity_key.is_some() { + len += 1; + } + if !self.pre_keys.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PrivateKeyBundleV1", len)?; + if let Some(v) = self.identity_key.as_ref() { + struct_ser.serialize_field("identityKey", v)?; + } + if !self.pre_keys.is_empty() { + struct_ser.serialize_field("preKeys", &self.pre_keys)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PrivateKeyBundleV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "identity_key", + "identityKey", + "pre_keys", + "preKeys", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IdentityKey, + PreKeys, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "preKeys" | "pre_keys" => Ok(GeneratedField::PreKeys), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrivateKeyBundleV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PrivateKeyBundleV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut identity_key__ = None; + let mut pre_keys__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IdentityKey => { + if identity_key__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + identity_key__ = map.next_value()?; + } + GeneratedField::PreKeys => { + if pre_keys__.is_some() { + return Err(serde::de::Error::duplicate_field("preKeys")); + } + pre_keys__ = Some(map.next_value()?); + } + } + } + Ok(PrivateKeyBundleV1 { + identity_key: identity_key__, + pre_keys: pre_keys__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PrivateKeyBundleV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PrivateKeyBundleV2 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.identity_key.is_some() { + len += 1; + } + if !self.pre_keys.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PrivateKeyBundleV2", len)?; + if let Some(v) = self.identity_key.as_ref() { + struct_ser.serialize_field("identityKey", v)?; + } + if !self.pre_keys.is_empty() { + struct_ser.serialize_field("preKeys", &self.pre_keys)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PrivateKeyBundleV2 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "identity_key", + "identityKey", + "pre_keys", + "preKeys", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IdentityKey, + PreKeys, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "preKeys" | "pre_keys" => Ok(GeneratedField::PreKeys), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PrivateKeyBundleV2; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PrivateKeyBundleV2") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut identity_key__ = None; + let mut pre_keys__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IdentityKey => { + if identity_key__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + identity_key__ = map.next_value()?; + } + GeneratedField::PreKeys => { + if pre_keys__.is_some() { + return Err(serde::de::Error::duplicate_field("preKeys")); + } + pre_keys__ = Some(map.next_value()?); + } + } + } + Ok(PrivateKeyBundleV2 { + identity_key: identity_key__, + pre_keys: pre_keys__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PrivateKeyBundleV2", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PublicKey { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.timestamp != 0 { + len += 1; + } + if self.signature.is_some() { + len += 1; + } + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PublicKey", len)?; + if self.timestamp != 0 { + struct_ser.serialize_field("timestamp", ToString::to_string(&self.timestamp).as_str())?; + } + if let Some(v) = self.signature.as_ref() { + struct_ser.serialize_field("signature", v)?; + } + if let Some(v) = self.union.as_ref() { + match v { + public_key::Union::Secp256k1Uncompressed(v) => { + struct_ser.serialize_field("secp256k1Uncompressed", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PublicKey { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "timestamp", + "signature", + "secp256k1_uncompressed", + "secp256k1Uncompressed", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Timestamp, + Signature, + Secp256k1Uncompressed, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "timestamp" => Ok(GeneratedField::Timestamp), + "signature" => Ok(GeneratedField::Signature), + "secp256k1Uncompressed" | "secp256k1_uncompressed" => Ok(GeneratedField::Secp256k1Uncompressed), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PublicKey; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PublicKey") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut timestamp__ = None; + let mut signature__ = None; + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Timestamp => { + if timestamp__.is_some() { + return Err(serde::de::Error::duplicate_field("timestamp")); + } + timestamp__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = map.next_value()?; + } + GeneratedField::Secp256k1Uncompressed => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("secp256k1Uncompressed")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(public_key::Union::Secp256k1Uncompressed) +; + } + } + } + Ok(PublicKey { + timestamp: timestamp__.unwrap_or_default(), + signature: signature__, + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PublicKey", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for public_key::Secp256k1Uncompressed { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PublicKey.Secp256k1Uncompressed", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for public_key::Secp256k1Uncompressed { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = public_key::Secp256k1Uncompressed; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PublicKey.Secp256k1Uncompressed") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(public_key::Secp256k1Uncompressed { + bytes: bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PublicKey.Secp256k1Uncompressed", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for PublicKeyBundle { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.identity_key.is_some() { + len += 1; + } + if self.pre_key.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.PublicKeyBundle", len)?; + if let Some(v) = self.identity_key.as_ref() { + struct_ser.serialize_field("identityKey", v)?; + } + if let Some(v) = self.pre_key.as_ref() { + struct_ser.serialize_field("preKey", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for PublicKeyBundle { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "identity_key", + "identityKey", + "pre_key", + "preKey", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IdentityKey, + PreKey, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "preKey" | "pre_key" => Ok(GeneratedField::PreKey), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = PublicKeyBundle; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.PublicKeyBundle") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut identity_key__ = None; + let mut pre_key__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IdentityKey => { + if identity_key__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + identity_key__ = map.next_value()?; + } + GeneratedField::PreKey => { + if pre_key__.is_some() { + return Err(serde::de::Error::duplicate_field("preKey")); + } + pre_key__ = map.next_value()?; + } + } + } + Ok(PublicKeyBundle { + identity_key: identity_key__, + pre_key: pre_key__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.PublicKeyBundle", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SealedInvitation { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SealedInvitation", len)?; + if let Some(v) = self.version.as_ref() { + match v { + sealed_invitation::Version::V1(v) => { + struct_ser.serialize_field("v1", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SealedInvitation { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "v1", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + V1, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "v1" => Ok(GeneratedField::V1), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SealedInvitation; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SealedInvitation") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::V1 => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("v1")); + } + version__ = map.next_value::<::std::option::Option<_>>()?.map(sealed_invitation::Version::V1) +; + } + } + } + Ok(SealedInvitation { + version: version__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SealedInvitation", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SealedInvitationHeaderV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.sender.is_some() { + len += 1; + } + if self.recipient.is_some() { + len += 1; + } + if self.created_ns != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SealedInvitationHeaderV1", len)?; + if let Some(v) = self.sender.as_ref() { + struct_ser.serialize_field("sender", v)?; + } + if let Some(v) = self.recipient.as_ref() { + struct_ser.serialize_field("recipient", v)?; + } + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SealedInvitationHeaderV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "sender", + "recipient", + "created_ns", + "createdNs", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Sender, + Recipient, + CreatedNs, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "sender" => Ok(GeneratedField::Sender), + "recipient" => Ok(GeneratedField::Recipient), + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SealedInvitationHeaderV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SealedInvitationHeaderV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut sender__ = None; + let mut recipient__ = None; + let mut created_ns__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = map.next_value()?; + } + GeneratedField::Recipient => { + if recipient__.is_some() { + return Err(serde::de::Error::duplicate_field("recipient")); + } + recipient__ = map.next_value()?; + } + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(SealedInvitationHeaderV1 { + sender: sender__, + recipient: recipient__, + created_ns: created_ns__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SealedInvitationHeaderV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SealedInvitationV1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.header_bytes.is_empty() { + len += 1; + } + if self.ciphertext.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SealedInvitationV1", len)?; + if !self.header_bytes.is_empty() { + struct_ser.serialize_field("headerBytes", pbjson::private::base64::encode(&self.header_bytes).as_str())?; + } + if let Some(v) = self.ciphertext.as_ref() { + struct_ser.serialize_field("ciphertext", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SealedInvitationV1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "header_bytes", + "headerBytes", + "ciphertext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + HeaderBytes, + Ciphertext, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "headerBytes" | "header_bytes" => Ok(GeneratedField::HeaderBytes), + "ciphertext" => Ok(GeneratedField::Ciphertext), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SealedInvitationV1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SealedInvitationV1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut header_bytes__ = None; + let mut ciphertext__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::HeaderBytes => { + if header_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("headerBytes")); + } + header_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Ciphertext => { + if ciphertext__.is_some() { + return Err(serde::de::Error::duplicate_field("ciphertext")); + } + ciphertext__ = map.next_value()?; + } + } + } + Ok(SealedInvitationV1 { + header_bytes: header_bytes__.unwrap_or_default(), + ciphertext: ciphertext__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SealedInvitationV1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for Signature { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Signature", len)?; + if let Some(v) = self.union.as_ref() { + match v { + signature::Union::EcdsaCompact(v) => { + struct_ser.serialize_field("ecdsaCompact", v)?; + } + signature::Union::WalletEcdsaCompact(v) => { + struct_ser.serialize_field("walletEcdsaCompact", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for Signature { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ecdsa_compact", + "ecdsaCompact", + "wallet_ecdsa_compact", + "walletEcdsaCompact", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EcdsaCompact, + WalletEcdsaCompact, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ecdsaCompact" | "ecdsa_compact" => Ok(GeneratedField::EcdsaCompact), + "walletEcdsaCompact" | "wallet_ecdsa_compact" => Ok(GeneratedField::WalletEcdsaCompact), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = Signature; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Signature") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EcdsaCompact => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("ecdsaCompact")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(signature::Union::EcdsaCompact) +; + } + GeneratedField::WalletEcdsaCompact => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("walletEcdsaCompact")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(signature::Union::WalletEcdsaCompact) +; + } + } + } + Ok(Signature { + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Signature", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for signature::EcdsaCompact { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + if self.recovery != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Signature.ECDSACompact", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + if self.recovery != 0 { + struct_ser.serialize_field("recovery", &self.recovery)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for signature::EcdsaCompact { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + "recovery", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + Recovery, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + "recovery" => Ok(GeneratedField::Recovery), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = signature::EcdsaCompact; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Signature.ECDSACompact") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + let mut recovery__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Recovery => { + if recovery__.is_some() { + return Err(serde::de::Error::duplicate_field("recovery")); + } + recovery__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(signature::EcdsaCompact { + bytes: bytes__.unwrap_or_default(), + recovery: recovery__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Signature.ECDSACompact", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for signature::WalletEcdsaCompact { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + if self.recovery != 0 { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.Signature.WalletECDSACompact", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + if self.recovery != 0 { + struct_ser.serialize_field("recovery", &self.recovery)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for signature::WalletEcdsaCompact { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + "recovery", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + Recovery, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + "recovery" => Ok(GeneratedField::Recovery), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = signature::WalletEcdsaCompact; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.Signature.WalletECDSACompact") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + let mut recovery__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Recovery => { + if recovery__.is_some() { + return Err(serde::de::Error::duplicate_field("recovery")); + } + recovery__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + } + } + Ok(signature::WalletEcdsaCompact { + bytes: bytes__.unwrap_or_default(), + recovery: recovery__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.Signature.WalletECDSACompact", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignedContent { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.payload.is_empty() { + len += 1; + } + if self.sender.is_some() { + len += 1; + } + if self.signature.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedContent", len)?; + if !self.payload.is_empty() { + struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?; + } + if let Some(v) = self.sender.as_ref() { + struct_ser.serialize_field("sender", v)?; + } + if let Some(v) = self.signature.as_ref() { + struct_ser.serialize_field("signature", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignedContent { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "payload", + "sender", + "signature", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Payload, + Sender, + Signature, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "payload" => Ok(GeneratedField::Payload), + "sender" => Ok(GeneratedField::Sender), + "signature" => Ok(GeneratedField::Signature), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignedContent; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedContent") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut payload__ = None; + let mut sender__ = None; + let mut signature__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Payload => { + if payload__.is_some() { + return Err(serde::de::Error::duplicate_field("payload")); + } + payload__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Sender => { + if sender__.is_some() { + return Err(serde::de::Error::duplicate_field("sender")); + } + sender__ = map.next_value()?; + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = map.next_value()?; + } + } + } + Ok(SignedContent { + payload: payload__.unwrap_or_default(), + sender: sender__, + signature: signature__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedContent", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignedEciesCiphertext { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.ecies_bytes.is_empty() { + len += 1; + } + if self.signature.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedEciesCiphertext", len)?; + if !self.ecies_bytes.is_empty() { + struct_ser.serialize_field("eciesBytes", pbjson::private::base64::encode(&self.ecies_bytes).as_str())?; + } + if let Some(v) = self.signature.as_ref() { + struct_ser.serialize_field("signature", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignedEciesCiphertext { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ecies_bytes", + "eciesBytes", + "signature", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EciesBytes, + Signature, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "eciesBytes" | "ecies_bytes" => Ok(GeneratedField::EciesBytes), + "signature" => Ok(GeneratedField::Signature), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignedEciesCiphertext; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedEciesCiphertext") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut ecies_bytes__ = None; + let mut signature__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EciesBytes => { + if ecies_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("eciesBytes")); + } + ecies_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = map.next_value()?; + } + } + } + Ok(SignedEciesCiphertext { + ecies_bytes: ecies_bytes__.unwrap_or_default(), + signature: signature__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedEciesCiphertext", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for signed_ecies_ciphertext::Ecies { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.ephemeral_public_key.is_empty() { + len += 1; + } + if !self.iv.is_empty() { + len += 1; + } + if !self.mac.is_empty() { + len += 1; + } + if !self.ciphertext.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedEciesCiphertext.Ecies", len)?; + if !self.ephemeral_public_key.is_empty() { + struct_ser.serialize_field("ephemeralPublicKey", pbjson::private::base64::encode(&self.ephemeral_public_key).as_str())?; + } + if !self.iv.is_empty() { + struct_ser.serialize_field("iv", pbjson::private::base64::encode(&self.iv).as_str())?; + } + if !self.mac.is_empty() { + struct_ser.serialize_field("mac", pbjson::private::base64::encode(&self.mac).as_str())?; + } + if !self.ciphertext.is_empty() { + struct_ser.serialize_field("ciphertext", pbjson::private::base64::encode(&self.ciphertext).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for signed_ecies_ciphertext::Ecies { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "ephemeral_public_key", + "ephemeralPublicKey", + "iv", + "mac", + "ciphertext", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + EphemeralPublicKey, + Iv, + Mac, + Ciphertext, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "ephemeralPublicKey" | "ephemeral_public_key" => Ok(GeneratedField::EphemeralPublicKey), + "iv" => Ok(GeneratedField::Iv), + "mac" => Ok(GeneratedField::Mac), + "ciphertext" => Ok(GeneratedField::Ciphertext), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = signed_ecies_ciphertext::Ecies; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedEciesCiphertext.Ecies") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut ephemeral_public_key__ = None; + let mut iv__ = None; + let mut mac__ = None; + let mut ciphertext__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::EphemeralPublicKey => { + if ephemeral_public_key__.is_some() { + return Err(serde::de::Error::duplicate_field("ephemeralPublicKey")); + } + ephemeral_public_key__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Iv => { + if iv__.is_some() { + return Err(serde::de::Error::duplicate_field("iv")); + } + iv__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Mac => { + if mac__.is_some() { + return Err(serde::de::Error::duplicate_field("mac")); + } + mac__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Ciphertext => { + if ciphertext__.is_some() { + return Err(serde::de::Error::duplicate_field("ciphertext")); + } + ciphertext__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(signed_ecies_ciphertext::Ecies { + ephemeral_public_key: ephemeral_public_key__.unwrap_or_default(), + iv: iv__.unwrap_or_default(), + mac: mac__.unwrap_or_default(), + ciphertext: ciphertext__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedEciesCiphertext.Ecies", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignedPrivateKey { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_ns != 0 { + len += 1; + } + if self.public_key.is_some() { + len += 1; + } + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedPrivateKey", len)?; + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + if let Some(v) = self.public_key.as_ref() { + struct_ser.serialize_field("publicKey", v)?; + } + if let Some(v) = self.union.as_ref() { + match v { + signed_private_key::Union::Secp256k1(v) => { + struct_ser.serialize_field("secp256k1", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignedPrivateKey { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_ns", + "createdNs", + "public_key", + "publicKey", + "secp256k1", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedNs, + PublicKey, + Secp256k1, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + "publicKey" | "public_key" => Ok(GeneratedField::PublicKey), + "secp256k1" => Ok(GeneratedField::Secp256k1), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignedPrivateKey; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedPrivateKey") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_ns__ = None; + let mut public_key__ = None; + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::PublicKey => { + if public_key__.is_some() { + return Err(serde::de::Error::duplicate_field("publicKey")); + } + public_key__ = map.next_value()?; + } + GeneratedField::Secp256k1 => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("secp256k1")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(signed_private_key::Union::Secp256k1) +; + } + } + } + Ok(SignedPrivateKey { + created_ns: created_ns__.unwrap_or_default(), + public_key: public_key__, + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedPrivateKey", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for signed_private_key::Secp256k1 { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedPrivateKey.Secp256k1", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for signed_private_key::Secp256k1 { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = signed_private_key::Secp256k1; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedPrivateKey.Secp256k1") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(signed_private_key::Secp256k1 { + bytes: bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedPrivateKey.Secp256k1", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignedPublicKey { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key_bytes.is_empty() { + len += 1; + } + if self.signature.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedPublicKey", len)?; + if !self.key_bytes.is_empty() { + struct_ser.serialize_field("keyBytes", pbjson::private::base64::encode(&self.key_bytes).as_str())?; + } + if let Some(v) = self.signature.as_ref() { + struct_ser.serialize_field("signature", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignedPublicKey { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_bytes", + "keyBytes", + "signature", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyBytes, + Signature, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyBytes" | "key_bytes" => Ok(GeneratedField::KeyBytes), + "signature" => Ok(GeneratedField::Signature), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignedPublicKey; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedPublicKey") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_bytes__ = None; + let mut signature__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::KeyBytes => { + if key_bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("keyBytes")); + } + key_bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Signature => { + if signature__.is_some() { + return Err(serde::de::Error::duplicate_field("signature")); + } + signature__ = map.next_value()?; + } + } + } + Ok(SignedPublicKey { + key_bytes: key_bytes__.unwrap_or_default(), + signature: signature__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedPublicKey", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for SignedPublicKeyBundle { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.identity_key.is_some() { + len += 1; + } + if self.pre_key.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.SignedPublicKeyBundle", len)?; + if let Some(v) = self.identity_key.as_ref() { + struct_ser.serialize_field("identityKey", v)?; + } + if let Some(v) = self.pre_key.as_ref() { + struct_ser.serialize_field("preKey", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for SignedPublicKeyBundle { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "identity_key", + "identityKey", + "pre_key", + "preKey", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + IdentityKey, + PreKey, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "identityKey" | "identity_key" => Ok(GeneratedField::IdentityKey), + "preKey" | "pre_key" => Ok(GeneratedField::PreKey), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = SignedPublicKeyBundle; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.SignedPublicKeyBundle") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut identity_key__ = None; + let mut pre_key__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::IdentityKey => { + if identity_key__.is_some() { + return Err(serde::de::Error::duplicate_field("identityKey")); + } + identity_key__ = map.next_value()?; + } + GeneratedField::PreKey => { + if pre_key__.is_some() { + return Err(serde::de::Error::duplicate_field("preKey")); + } + pre_key__ = map.next_value()?; + } + } + } + Ok(SignedPublicKeyBundle { + identity_key: identity_key__, + pre_key: pre_key__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.SignedPublicKeyBundle", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for UnsignedPublicKey { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.created_ns != 0 { + len += 1; + } + if self.union.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.UnsignedPublicKey", len)?; + if self.created_ns != 0 { + struct_ser.serialize_field("createdNs", ToString::to_string(&self.created_ns).as_str())?; + } + if let Some(v) = self.union.as_ref() { + match v { + unsigned_public_key::Union::Secp256k1Uncompressed(v) => { + struct_ser.serialize_field("secp256k1Uncompressed", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for UnsignedPublicKey { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "created_ns", + "createdNs", + "secp256k1_uncompressed", + "secp256k1Uncompressed", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + CreatedNs, + Secp256k1Uncompressed, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "createdNs" | "created_ns" => Ok(GeneratedField::CreatedNs), + "secp256k1Uncompressed" | "secp256k1_uncompressed" => Ok(GeneratedField::Secp256k1Uncompressed), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = UnsignedPublicKey; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.UnsignedPublicKey") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut created_ns__ = None; + let mut union__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::CreatedNs => { + if created_ns__.is_some() { + return Err(serde::de::Error::duplicate_field("createdNs")); + } + created_ns__ = + Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Secp256k1Uncompressed => { + if union__.is_some() { + return Err(serde::de::Error::duplicate_field("secp256k1Uncompressed")); + } + union__ = map.next_value::<::std::option::Option<_>>()?.map(unsigned_public_key::Union::Secp256k1Uncompressed) +; + } + } + } + Ok(UnsignedPublicKey { + created_ns: created_ns__.unwrap_or_default(), + union: union__, + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.UnsignedPublicKey", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for unsigned_public_key::Secp256k1Uncompressed { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.bytes.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("xmtp.message_contents.UnsignedPublicKey.Secp256k1Uncompressed", len)?; + if !self.bytes.is_empty() { + struct_ser.serialize_field("bytes", pbjson::private::base64::encode(&self.bytes).as_str())?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for unsigned_public_key::Secp256k1Uncompressed { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "bytes", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Bytes, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "bytes" => Ok(GeneratedField::Bytes), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = unsigned_public_key::Secp256k1Uncompressed; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct xmtp.message_contents.UnsignedPublicKey.Secp256k1Uncompressed") + } + + fn visit_map(self, mut map: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut bytes__ = None; + while let Some(k) = map.next_key()? { + match k { + GeneratedField::Bytes => { + if bytes__.is_some() { + return Err(serde::de::Error::duplicate_field("bytes")); + } + bytes__ = + Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + } + } + Ok(unsigned_public_key::Secp256k1Uncompressed { + bytes: bytes__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("xmtp.message_contents.UnsignedPublicKey.Secp256k1Uncompressed", FIELDS, GeneratedVisitor) + } +} diff --git a/crates/xmtp-proto/src/lib.rs b/crates/xmtp-proto/src/lib.rs new file mode 100644 index 000000000..e383550c0 --- /dev/null +++ b/crates/xmtp-proto/src/lib.rs @@ -0,0 +1,9 @@ +use tonic::transport::Channel; + +use crate::xmtp::message_api::v1::message_api_client::MessageApiClient; + +include!("gen/mod.rs"); + +pub async fn create_client(url: String) -> MessageApiClient { + return MessageApiClient::connect(url).await.unwrap(); +}