From 59de99466e98d54ceb79b905c2aa3e8a6bbe31bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20=F0=9F=90=86?= Date: Thu, 8 Oct 2026 09:32:01 -0400 Subject: [PATCH 1/5] Add KFP v2 transport, announce proof and NIP-44 primitives to frost_tr --- components/frost_tr/include/frost_tr.h | 43 + components/frost_tr/rust/Cargo.lock | 95 + components/frost_tr/rust/Cargo.toml | 7 +- components/frost_tr/rust/src/kfp.rs | 334 ++++ components/frost_tr/rust/src/lib.rs | 434 +++++ components/frost_tr/rust/vectors/kfp.json | 2001 +++++++++++++++++++++ 6 files changed, 2913 insertions(+), 1 deletion(-) create mode 100644 components/frost_tr/rust/src/kfp.rs create mode 100644 components/frost_tr/rust/vectors/kfp.json diff --git a/components/frost_tr/include/frost_tr.h b/components/frost_tr/include/frost_tr.h index 8b6c039..04d4b3c 100644 --- a/components/frost_tr/include/frost_tr.h +++ b/components/frost_tr/include/frost_tr.h @@ -24,6 +24,7 @@ extern "C" { #define FTR_MAX_SIGNERS 16 #define FTR_SIGNING_PACKAGE_MAX 1687 #define FTR_MAX_PATH_DEPTH 8 +#define FTR_KFP_MAX_PLAINTEXT 65408 // Status codes of the key package and signing calls (see rust/src/signer.rs). #define FTR_OK 0 @@ -42,6 +43,9 @@ extern "C" { #define FTR_E_SELFCHECK -13 #define FTR_E_PATH -14 #define FTR_E_TWEAK -15 +#define FTR_E_KEY -16 +#define FTR_E_DECRYPT -17 +#define FTR_E_CAPACITY -18 typedef struct { uint16_t index; @@ -97,6 +101,45 @@ int ftr_sign(const uint8_t *kp, size_t kp_len, uint8_t nonces[FTR_NONCES_LEN], const uint8_t expected_message[FTR_MESSAGE_LEN], const uint32_t *path, size_t path_len, bool taproot, const uint8_t *merkle_root, uint8_t out_share[FTR_SIGNATURE_SHARE_LEN]); +// KFP v2 (keep-frost-net), with the transport key derived inside from the key +// package, so it never leaves the device and no caller supplies it. + +// The x-only transport public key keep derives from the key package. +int ftr_kfp_transport_pubkey(const uint8_t *kp, size_t kp_len, uint8_t out[32]); + +// The announce proof binding this key package's transport key at `timestamp`. +int ftr_kfp_announce_proof(const uint8_t *kp, size_t kp_len, uint64_t timestamp, uint8_t out[64]); + +// The rendezvous address keep announces to for member `index` of `group`. +int ftr_kfp_rendezvous(const uint8_t group[32], uint16_t index, uint8_t out[32]); + +// NIP-44 v2 from the transport key to the x-only `recipient`: a base64 payload +// of up to `cap` bytes, not NUL-terminated. Plaintext is 1..FTR_KFP_MAX_PLAINTEXT. +int ftr_kfp_seal(const uint8_t *kp, size_t kp_len, const uint8_t recipient[32], + const uint8_t *plaintext, size_t plaintext_len, uint8_t *out, size_t cap, + size_t *out_len); + +// Opens a NIP-44 v2 base64 payload the x-only `sender` sealed to the transport +// key. Writes nothing unless the MAC verifies; the caller wipes `out` after use. +int ftr_kfp_open(const uint8_t *kp, size_t kp_len, const uint8_t sender[32], const uint8_t *payload, + size_t payload_len, uint8_t *out, size_t cap, size_t *out_len); + +// The NIP-01 id of a serialized event built by the firmware +// (`[0,pubkey,created_at,kind,tags,content]`) and its BIP-340 signature by the +// transport key. Never to be called with bytes a host chose. +int ftr_kfp_sign_event(const uint8_t *kp, size_t kp_len, const uint8_t *serialized, + size_t serialized_len, uint8_t out_id[32], uint8_t out_sig[64]); + +// keep's salted session id (BLAKE2b-512, first 32 bytes) for a sign request. +int ftr_kfp_session_id(const uint8_t *message, size_t message_len, const uint16_t *participants, + size_t participants_len, uint16_t threshold, const uint8_t *salt, + size_t salt_len, uint8_t out[32]); + +// 1 when `salt` binds the request's path and taproot tweak, 0 when it does not, +// or a negative error code. +int ftr_kfp_salt_binds(const uint8_t *salt, size_t salt_len, const uint32_t *path, size_t path_len, + bool taproot, const uint8_t *merkle_root); + #ifdef __cplusplus } #endif diff --git a/components/frost_tr/rust/Cargo.lock b/components/frost_tr/rust/Cargo.lock index 196bf7f..e67b5e5 100644 --- a/components/frost_tr/rust/Cargo.lock +++ b/components/frost_tr/rust/Cargo.lock @@ -17,6 +17,21 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest", +] + [[package]] name = "block-buffer" version = "0.10.4" @@ -38,6 +53,27 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" +[[package]] +name = "chacha20" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[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 = "cobs" version = "0.3.0" @@ -124,7 +160,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer", + "const-oid", "crypto-common", + "subtle", ] [[package]] @@ -136,6 +174,18 @@ dependencies = [ "litrs", ] +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der", + "digest", + "elliptic-curve", + "signature", +] + [[package]] name = "either" version = "1.19.0" @@ -235,8 +285,13 @@ dependencies = [ name = "frost_tr" version = "0.1.0" dependencies = [ + "base64ct", + "blake2", + "chacha20", "frost-core", "frost-secp256k1-tr", + "hkdf", + "hmac", "k256", "rand_core", "serde_json", @@ -295,6 +350,33 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" +[[package]] +name = "hkdf" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" +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 = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + [[package]] name = "itertools" version = "0.14.0" @@ -317,7 +399,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" dependencies = [ "cfg-if", + "ecdsa", "elliptic-curve", + "sha2", + "signature", ] [[package]] @@ -488,6 +573,16 @@ dependencies = [ "digest", ] +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest", + "rand_core", +] + [[package]] name = "spin" version = "0.9.9" diff --git a/components/frost_tr/rust/Cargo.toml b/components/frost_tr/rust/Cargo.toml index 1ae1dbf..edc5595 100644 --- a/components/frost_tr/rust/Cargo.toml +++ b/components/frost_tr/rust/Cargo.toml @@ -12,10 +12,15 @@ crate-type = ["staticlib", "rlib"] [dependencies] frost-secp256k1-tr = { version = "=3.0.0", default-features = false, features = ["serialization"] } frost-core = { version = "=3.0.0", default-features = false, features = ["serialization"] } -k256 = { version = "=0.13.4", default-features = false, features = ["arithmetic"] } +k256 = { version = "=0.13.4", default-features = false, features = ["arithmetic", "schnorr"] } rand_core = { version = "=0.6.4", default-features = false } sha2 = { version = "=0.10.9", default-features = false } zeroize = { version = "=1.9.1", default-features = false } +base64ct = { version = "=1.8.3", default-features = false, features = ["alloc"] } +blake2 = { version = "=0.10.6", default-features = false } +chacha20 = { version = "=0.9.1", default-features = false } +hkdf = { version = "=0.12.4", default-features = false } +hmac = { version = "=0.12.1", default-features = false } [dev-dependencies] serde_json = "=1.0.145" diff --git a/components/frost_tr/rust/src/kfp.rs b/components/frost_tr/rust/src/kfp.rs new file mode 100644 index 0000000..ceafa12 --- /dev/null +++ b/components/frost_tr/rust/src/kfp.rs @@ -0,0 +1,334 @@ +// SPDX-FileCopyrightText: © 2026 PrivKey LLC +// SPDX-License-Identifier: MIT + +//! The cryptography of a KFP v2 participant (keep-frost-net), derived from the +//! stored key package so no transport secret ever leaves the device: the +//! transport key, the announce proof, rendezvous addresses, NIP-44 v2 +//! encryption between transport keys, BIP-340 event signatures and the salted +//! session id. Checked byte for byte against vectors from keep's own code +//! (`vectors/kfp.json`). + +use alloc::vec::Vec; + +use base64ct::{Base64, Encoding}; +use blake2::Blake2b512; +use chacha20::cipher::{KeyIvInit, StreamCipher}; +use chacha20::ChaCha20; +use frost_secp256k1_tr::keys::KeyPackage; +use hkdf::Hkdf; +use hmac::{Hmac, Mac}; +use k256::elliptic_curve::point::AffineCoordinates; +use k256::schnorr::SigningKey; +use k256::{AffinePoint, ProjectivePoint, PublicKey, SecretKey}; +use rand_core::RngCore; +use sha2::{Digest, Sha256}; +use zeroize::{Zeroize, Zeroizing}; + +use crate::rng::DeviceRng; +use crate::signer::{identifier_index, E_IDENTIFIER}; + +pub const E_KEY: i32 = -16; +pub const E_DECRYPT: i32 = -17; +pub const E_CAPACITY: i32 = -18; + +const TRANSPORT_DOMAIN: &[u8] = b"keep-frost-transport-v2"; +const PROOF_DOMAIN: &[u8] = b"keep-frost-announce-proof-v2"; +const RENDEZVOUS_DOMAIN: &[u8] = b"keep-frost-rendezvous-v2"; +const SESSION_DOMAIN: &[u8] = b"keep-frost-session-v1"; +const SESSION_VERSION: u8 = 0x02; +const TWEAK_MARKER: [u8; 3] = [0xff, b'T', b'R']; + +/// NIP-44 v2 bounds (as the nostr crate keep uses enforces them). +pub const MAX_PLAINTEXT: usize = 65_536 - 128; +const MIN_PAYLOAD: usize = 1 + 32 + 2 + 32 + 32; +const MAX_PAYLOAD: usize = 1 + 32 + 2 + padded_len(MAX_PLAINTEXT) + 32; + +fn group_xonly(kp: &KeyPackage) -> Result<[u8; 32], i32> { + let vk = kp.verifying_key().serialize().map_err(|_| E_KEY)?; + vk.get(1..33).and_then(|x| x.try_into().ok()).ok_or(E_KEY) +} + +/// The transport key keep derives from a share: the first +/// `SHA256(domain || share || group_xonly || index_be || counter)` that is a +/// valid secret key. +pub fn transport_secret(kp: &KeyPackage) -> Result { + let group = group_xonly(kp)?; + let index = identifier_index(kp.identifier()).ok_or(E_IDENTIFIER)?; + let share = Zeroizing::new(kp.signing_share().serialize()); + for counter in 0u8..=255 { + let mut digest: [u8; 32] = Sha256::new() + .chain_update(TRANSPORT_DOMAIN) + .chain_update(&share[..]) + .chain_update(group) + .chain_update(index.to_be_bytes()) + .chain_update([counter]) + .finalize() + .into(); + let key = SecretKey::from_slice(&digest); + digest.zeroize(); + if let Ok(key) = key { + return Ok(key); + } + } + Err(E_KEY) +} + +fn xonly(public: &PublicKey) -> [u8; 32] { + public.as_affine().x().into() +} + +pub fn transport_pubkey(kp: &KeyPackage) -> Result<[u8; 32], i32> { + Ok(xonly(&transport_secret(kp)?.public_key())) +} + +/// The announce proof binding `transport_xonly` to this share: keep's +/// `sign_proof`, BIP-340 by the signing share over SHA256 of the proof digest, +/// with zero auxiliary randomness. +pub fn announce_proof(kp: &KeyPackage, transport_xonly: &[u8; 32], timestamp: u64) -> Result<[u8; 64], i32> { + let group = group_xonly(kp)?; + let index = identifier_index(kp.identifier()).ok_or(E_IDENTIFIER)?; + let verifying_share = kp.verifying_share().serialize().map_err(|_| E_KEY)?; + let digest = Sha256::new() + .chain_update(PROOF_DOMAIN) + .chain_update(group) + .chain_update(index.to_be_bytes()) + .chain_update(&verifying_share) + .chain_update(transport_xonly) + .chain_update(timestamp.to_be_bytes()) + .finalize(); + let share = Zeroizing::new(kp.signing_share().serialize()); + let key = SigningKey::from_bytes(&share).map_err(|_| E_KEY)?; + let sig = key.sign_raw(&Sha256::digest(digest), &[0u8; 32]).map_err(|_| E_KEY)?; + Ok(sig.to_bytes()) +} + +/// The public routing address keep announces to for member `index`: the first +/// `SHA256(domain || group || index_be || counter)` that is an x coordinate. +pub fn rendezvous(group: &[u8; 32], index: u16) -> Result<[u8; 32], i32> { + for counter in 0u8..=255 { + let x: [u8; 32] = Sha256::new() + .chain_update(RENDEZVOUS_DOMAIN) + .chain_update(group) + .chain_update(index.to_be_bytes()) + .chain_update([counter]) + .finalize() + .into(); + if lift_x(&x).is_some() { + return Ok(x); + } + } + Err(E_KEY) +} + +fn lift_x(x: &[u8; 32]) -> Option { + let mut sec1 = [0x02u8; 33]; + sec1[1..].copy_from_slice(x); + PublicKey::from_sec1_bytes(&sec1).ok().map(|p| *p.as_affine()) +} + +/// The NIP-44 v2 conversation key between `secret` and the x-only `peer`: +/// HKDF-extract with salt "nip44-v2" over the x coordinate of their ECDH point. +fn conversation_key(secret: &SecretKey, peer: &[u8; 32]) -> Result, i32> { + let point = lift_x(peer).ok_or(E_KEY)?; + let shared = (ProjectivePoint::from(point) * *secret.to_nonzero_scalar()).to_affine(); + let mut shared_x: [u8; 32] = shared.x().into(); + let (prk, _) = Hkdf::::extract(Some(b"nip44-v2"), &shared_x); + shared_x.zeroize(); + let mut out = Zeroizing::new([0u8; 32]); + out.copy_from_slice(&prk); + Ok(out) +} + +struct MessageKeys(Zeroizing<[u8; 76]>); + +impl MessageKeys { + fn new(conversation: &[u8; 32], nonce: &[u8; 32]) -> Result { + let hk = Hkdf::::from_prk(conversation).map_err(|_| E_KEY)?; + let mut keys = Zeroizing::new([0u8; 76]); + hk.expand(nonce, &mut keys[..]).map_err(|_| E_KEY)?; + Ok(Self(keys)) + } + + fn cipher(&self) -> ChaCha20 { + ChaCha20::new(self.0[..32].into(), self.0[32..44].into()) + } + + fn mac(&self, nonce: &[u8; 32], ciphertext: &[u8]) -> Hmac { + let mut mac = as Mac>::new_from_slice(&self.0[44..]).expect("any key length"); + mac.update(nonce); + mac.update(ciphertext); + mac + } +} + +const fn padded_len(len: usize) -> usize { + if len <= 32 { + return 32; + } + let next_power = 1usize << (usize::BITS - (len - 1).leading_zeros()); + let chunk = if next_power <= 256 { 32 } else { next_power / 8 }; + chunk * ((len - 1) / chunk + 1) +} + +/// NIP-44 v2 payload (base64) of `plaintext` from this device's transport key +/// to the x-only `recipient`, under `nonce`. +pub fn seal_with_nonce(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8], nonce: &[u8; 32]) -> Result, i32> { + if plaintext.is_empty() || plaintext.len() > MAX_PLAINTEXT { + return Err(E_CAPACITY); + } + let conversation = conversation_key(&transport_secret(kp)?, recipient)?; + let keys = MessageKeys::new(&conversation, nonce)?; + let mut buffer = Zeroizing::new(Vec::with_capacity(2 + padded_len(plaintext.len()))); + buffer.extend_from_slice(&(plaintext.len() as u16).to_be_bytes()); + buffer.extend_from_slice(plaintext); + buffer.resize(2 + padded_len(plaintext.len()), 0); + keys.cipher().apply_keystream(&mut buffer); + let tag = keys.mac(nonce, &buffer).finalize().into_bytes(); + let mut payload = Vec::with_capacity(1 + 32 + buffer.len() + 32); + payload.push(2); + payload.extend_from_slice(nonce); + payload.extend_from_slice(&buffer); + payload.extend_from_slice(&tag); + let encoded = Base64::encode_string(&payload); + Ok(encoded.into_bytes()) +} + +pub fn seal(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8]) -> Result, i32> { + let mut nonce = [0u8; 32]; + DeviceRng.fill_bytes(&mut nonce); + seal_with_nonce(kp, recipient, plaintext, &nonce) +} + +/// The plaintext of a NIP-44 v2 `payload` (base64) the x-only `sender` sealed to +/// this device's transport key. The MAC is checked before anything is +/// decrypted, so a valid result was produced by the holder of `sender`'s key +/// (or by this device). +pub fn open(kp: &KeyPackage, sender: &[u8; 32], payload: &[u8]) -> Result>, i32> { + if payload.len() > (MAX_PAYLOAD + 2) / 3 * 4 { + return Err(E_CAPACITY); + } + let raw = Base64::decode_vec(core::str::from_utf8(payload).map_err(|_| E_DECRYPT)?).map_err(|_| E_DECRYPT)?; + if raw.len() < MIN_PAYLOAD || raw.len() > MAX_PAYLOAD || raw[0] != 2 { + return Err(E_DECRYPT); + } + let nonce: [u8; 32] = raw[1..33].try_into().map_err(|_| E_DECRYPT)?; + let (ciphertext, tag) = raw[33..].split_at(raw.len() - 33 - 32); + let conversation = conversation_key(&transport_secret(kp)?, sender)?; + let keys = MessageKeys::new(&conversation, &nonce)?; + keys.mac(&nonce, ciphertext).verify_slice(tag).map_err(|_| E_DECRYPT)?; + let mut buffer = Zeroizing::new(ciphertext.to_vec()); + keys.cipher().apply_keystream(&mut buffer); + let len = u16::from_be_bytes([buffer[0], buffer[1]]) as usize; + if len == 0 || buffer.len() != 2 + padded_len(len) { + return Err(E_DECRYPT); + } + Ok(Zeroizing::new(buffer[2..2 + len].to_vec())) +} + +/// The NIP-01 id of a serialized event (`[0,pubkey,created_at,kind,tags,content]`) +/// and its BIP-340 signature by this device's transport key. +pub fn sign_event(kp: &KeyPackage, serialized: &[u8]) -> Result<([u8; 32], [u8; 64]), i32> { + let id: [u8; 32] = Sha256::digest(serialized).into(); + let secret = transport_secret(kp)?; + let key = SigningKey::from(secret.to_nonzero_scalar()); + let mut aux = [0u8; 32]; + DeviceRng.fill_bytes(&mut aux); + let sig = key.sign_raw(&id, &aux).map_err(|_| E_KEY)?; + Ok((id, sig.to_bytes())) +} + +/// keep's salted session id: BLAKE2b-512 (first 32 bytes) over the domain, +/// version, threshold, the sorted participants, the message and, when present, +/// the salt. +pub fn session_id(message: &[u8], participants: &[u16], threshold: u16, salt: &[u8]) -> [u8; 32] { + let mut sorted = participants.to_vec(); + sorted.sort_unstable(); + let mut h = Blake2b512::new() + .chain_update(SESSION_DOMAIN) + .chain_update([SESSION_VERSION]) + .chain_update(threshold.to_be_bytes()) + .chain_update((sorted.len() as u16).to_be_bytes()); + for p in &sorted { + h.update(p.to_be_bytes()); + } + h.update((message.len() as u32).to_be_bytes()); + h.update(message); + if !salt.is_empty() { + h.update((salt.len() as u32).to_be_bytes()); + h.update(salt); + } + let digest = h.finalize(); + let mut out = [0u8; 32]; + out.copy_from_slice(&digest[..32]); + out +} + +/// Whether `salt` encodes the key a request signs with: empty only with no path +/// and no tweak, otherwise an 8-byte attempt counter followed by each path +/// index (big endian) and, for a key-path spend, `ff 'T' 'R'` then `00` or +/// `01 || merkle_root`. +pub fn salt_binds(salt: &[u8], path: &[u32], taproot: Option>) -> bool { + let mut suffix = Vec::with_capacity(path.len() * 4 + 36); + for i in path { + suffix.extend_from_slice(&i.to_be_bytes()); + } + if let Some(root) = taproot { + suffix.extend_from_slice(&TWEAK_MARKER); + match root { + None => suffix.push(0), + Some(r) => { + suffix.push(1); + suffix.extend_from_slice(&r); + } + } + } + if salt.is_empty() { + return suffix.is_empty(); + } + salt.len() >= 8 && salt[8..] == suffix[..] +} + +#[cfg(test)] +mod tests { + use super::*; + + fn unhex(s: &str) -> Vec { + (0..s.len()).step_by(2).map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap()).collect() + } + + /// A payload with a valid MAC around `padded`, the plaintext buffer before + /// encryption (length prefix and padding included). + fn authentic(kp: &KeyPackage, peer: &[u8; 32], padded: &[u8]) -> Vec { + let nonce = [7u8; 32]; + let conversation = conversation_key(&transport_secret(kp).unwrap(), peer).unwrap(); + let keys = MessageKeys::new(&conversation, &nonce).unwrap(); + let mut buffer = padded.to_vec(); + keys.cipher().apply_keystream(&mut buffer); + let tag = keys.mac(&nonce, &buffer).finalize().into_bytes(); + let mut raw = alloc::vec![2u8]; + raw.extend_from_slice(&nonce); + raw.extend_from_slice(&buffer); + raw.extend_from_slice(&tag); + Base64::encode_string(&raw).into_bytes() + } + + /// The length prefix must match the padding exactly; one that overruns the + /// buffer is refused, not read past. + #[test] + fn open_checks_the_length_prefix_against_the_padding() { + let v: serde_json::Value = serde_json::from_str(include_str!("../vectors/kfp.json")).unwrap(); + let g = &v["groups"][0]; + let kp = KeyPackage::deserialize(&unhex(g["key_packages"][0].as_str().unwrap())).unwrap(); + let peer: [u8; 32] = unhex(g["members"][0]["peer_pubkey"].as_str().unwrap()).try_into().unwrap(); + let buffer = |prefix: u16, body: usize| { + let mut b = prefix.to_be_bytes().to_vec(); + b.resize(2 + body, 0x41); + b + }; + assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(5, 32))).unwrap()[..], [0x41; 5]); + assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(40, 64))).unwrap()[..], [0x41; 40]); + for (prefix, body) in [(0u16, 32usize), (33, 32), (40, 32), (65_535, 32), (5, 64), (40, 96)] { + assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(prefix, body))).err(), Some(E_DECRYPT), "prefix {prefix}, body {body}"); + } + } +} diff --git a/components/frost_tr/rust/src/lib.rs b/components/frost_tr/rust/src/lib.rs index 1f20a2c..cb61ae7 100644 --- a/components/frost_tr/rust/src/lib.rs +++ b/components/frost_tr/rust/src/lib.rs @@ -11,6 +11,7 @@ extern crate alloc; mod bip32; mod glue; +mod kfp; mod rng; mod selftest; mod signer; @@ -181,6 +182,188 @@ pub unsafe extern "C" fn ftr_sign( status(signer::sign(kp, nonces, sp, msg, path, taproot, share)) } +fn kfp_key(kp: *const u8, kp_len: usize) -> Result { + signer::load(unsafe { slice(kp, kp_len) }.ok_or(signer::E_NULL)?) +} + +/// The x-only KFP v2 transport public key keep derives from this key package. +/// +/// # Safety +/// `kp` must point to `kp_len` readable bytes, `out` to 32 writable bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_transport_pubkey(kp: *const u8, kp_len: usize, out: *mut [u8; 32]) -> i32 { + let Some(out) = out.as_mut() else { return signer::E_NULL }; + status(kfp_key(kp, kp_len).and_then(|kp| kfp::transport_pubkey(&kp)).map(|k| *out = k)) +} + +/// The announce proof binding this key package's transport key at `timestamp`. +/// +/// # Safety +/// `kp` must point to `kp_len` readable bytes, `out` to 64 writable bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_announce_proof(kp: *const u8, kp_len: usize, timestamp: u64, out: *mut [u8; 64]) -> i32 { + let Some(out) = out.as_mut() else { return signer::E_NULL }; + let r = kfp_key(kp, kp_len).and_then(|kp| { + let transport = kfp::transport_pubkey(&kp)?; + kfp::announce_proof(&kp, &transport, timestamp) + }); + status(r.map(|sig| *out = sig)) +} + +/// The rendezvous address keep announces to for member `index` of `group`. +/// +/// # Safety +/// `group` must point to 32 readable bytes, `out` to 32 writable bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_rendezvous(group: *const [u8; 32], index: u16, out: *mut [u8; 32]) -> i32 { + let (Some(group), Some(out)) = (group.as_ref(), out.as_mut()) else { return signer::E_NULL }; + status(kfp::rendezvous(group, index).map(|x| *out = x)) +} + +/// Seals `plaintext` with NIP-44 v2 from this key package's transport key to +/// the x-only `recipient`, writing the base64 payload (not NUL-terminated). +/// +/// # Safety +/// The pointers must be valid for the given lengths; `out` for `cap` bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_seal( + kp: *const u8, + kp_len: usize, + recipient: *const [u8; 32], + plaintext: *const u8, + plaintext_len: usize, + out: *mut u8, + cap: usize, + out_len: *mut usize, +) -> i32 { + let (Some(recipient), Some(plaintext), Some(out_len)) = (recipient.as_ref(), slice(plaintext, plaintext_len), out_len.as_mut()) + else { + return signer::E_NULL; + }; + if out.is_null() { + return signer::E_NULL; + } + let r = kfp_key(kp, kp_len).and_then(|kp| kfp::seal(&kp, recipient, plaintext)).and_then(|payload| { + if payload.len() > cap { + return Err(kfp::E_CAPACITY); + } + core::ptr::copy_nonoverlapping(payload.as_ptr(), out, payload.len()); + *out_len = payload.len(); + Ok(()) + }); + status(r) +} + +/// Opens a NIP-44 v2 base64 `payload` the x-only `sender` sealed to this key +/// package's transport key. Nothing is written unless the MAC verifies. +/// +/// # Safety +/// The pointers must be valid for the given lengths; `out` for `cap` bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_open( + kp: *const u8, + kp_len: usize, + sender: *const [u8; 32], + payload: *const u8, + payload_len: usize, + out: *mut u8, + cap: usize, + out_len: *mut usize, +) -> i32 { + let (Some(sender), Some(payload), Some(out_len)) = (sender.as_ref(), slice(payload, payload_len), out_len.as_mut()) else { + return signer::E_NULL; + }; + if out.is_null() { + return signer::E_NULL; + } + let r = kfp_key(kp, kp_len).and_then(|kp| kfp::open(&kp, sender, payload)).and_then(|plain| { + if plain.len() > cap { + return Err(kfp::E_CAPACITY); + } + core::ptr::copy_nonoverlapping(plain.as_ptr(), out, plain.len()); + *out_len = plain.len(); + Ok(()) + }); + status(r) +} + +/// The NIP-01 id of `serialized` (`[0,pubkey,created_at,kind,tags,content]`) +/// and its BIP-340 signature by this key package's transport key. For events +/// the firmware builds itself; never reachable with host-chosen bytes. +/// +/// # Safety +/// `kp` and `serialized` must point to readable buffers of the given lengths, +/// `out_id` to 32 and `out_sig` to 64 writable bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_sign_event( + kp: *const u8, + kp_len: usize, + serialized: *const u8, + serialized_len: usize, + out_id: *mut [u8; 32], + out_sig: *mut [u8; 64], +) -> i32 { + let (Some(serialized), Some(out_id), Some(out_sig)) = (slice(serialized, serialized_len), out_id.as_mut(), out_sig.as_mut()) else { + return signer::E_NULL; + }; + let r = kfp_key(kp, kp_len).and_then(|kp| kfp::sign_event(&kp, serialized)); + status(r.map(|(id, sig)| { + *out_id = id; + *out_sig = sig; + })) +} + +/// keep's salted session id for a request. +/// +/// # Safety +/// The pointers must be valid for the given lengths (`salt` may be null when +/// `salt_len` is 0); `out` must point to 32 writable bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_session_id( + message: *const u8, + message_len: usize, + participants: *const u16, + participants_len: usize, + threshold: u16, + salt: *const u8, + salt_len: usize, + out: *mut [u8; 32], +) -> i32 { + let message = if message_len == 0 { Some(&[][..]) } else { slice(message, message_len) }; + let salt = if salt_len == 0 { Some(&[][..]) } else { slice(salt, salt_len) }; + if participants.is_null() || participants_len == 0 || participants_len > usize::from(signer::MAX_SIGNERS) { + return signer::E_NULL; + } + let (Some(message), Some(salt), Some(out)) = (message, salt, out.as_mut()) else { return signer::E_NULL }; + *out = kfp::session_id(message, core::slice::from_raw_parts(participants, participants_len), threshold, salt); + 0 +} + +/// 1 when `salt` binds the request's path and taproot tweak (as keep's +/// `salt_binds`), 0 when it does not, or an error code. +/// +/// # Safety +/// The pointers must be valid for the given lengths (null when 0); +/// `merkle_root`, when non-null, must point to 32 bytes. +#[no_mangle] +pub unsafe extern "C" fn ftr_kfp_salt_binds( + salt: *const u8, + salt_len: usize, + path: *const u32, + path_len: usize, + taproot: bool, + merkle_root: *const [u8; 32], +) -> i32 { + let salt = if salt_len == 0 { Some(&[][..]) } else { slice(salt, salt_len) }; + if path_len > bip32::MAX_DEPTH || (path_len > 0 && path.is_null()) || (!taproot && !merkle_root.is_null()) { + return signer::E_NULL; + } + let Some(salt) = salt else { return signer::E_NULL }; + let path = if path_len == 0 { &[][..] } else { core::slice::from_raw_parts(path, path_len) }; + let taproot = taproot.then(|| merkle_root.as_ref().copied()); + i32::from(kfp::salt_binds(salt, path, taproot)) +} + #[cfg(test)] mod tests { use super::*; @@ -607,6 +790,10 @@ mod tests { ("FTR_E_SELFCHECK", signer::E_SELFCHECK as i64), ("FTR_E_PATH", signer::E_PATH as i64), ("FTR_E_TWEAK", signer::E_TWEAK as i64), + ("FTR_E_KEY", kfp::E_KEY as i64), + ("FTR_E_DECRYPT", kfp::E_DECRYPT as i64), + ("FTR_E_CAPACITY", kfp::E_CAPACITY as i64), + ("FTR_KFP_MAX_PLAINTEXT", kfp::MAX_PLAINTEXT as i64), ("FTR_MAX_PATH_DEPTH", bip32::MAX_DEPTH as i64), ]; for (name, value) in expected { @@ -834,6 +1021,253 @@ mod tests { assert_eq!(out, [0u8; 32]); } + fn kfp_vectors() -> serde_json::Value { + serde_json::from_str(include_str!("../vectors/kfp.json")).unwrap() + } + + fn arr32(h: &str) -> [u8; 32] { + unhex(h).try_into().unwrap() + } + + /// Each member's (key package, vector) pair, in the vector file's order. + fn kfp_members(v: &serde_json::Value) -> Vec<(Vec, serde_json::Value, [u8; 32], u16)> { + let mut out = Vec::new(); + for g in v["groups"].as_array().unwrap() { + let group: [u8; 32] = unhex(g["group_key"].as_str().unwrap())[1..33].try_into().unwrap(); + let n = g["members"].as_array().unwrap().len() as u16; + for (kp, m) in g["key_packages"].as_array().unwrap().iter().zip(g["members"].as_array().unwrap()) { + out.push((unhex(kp.as_str().unwrap()), m.clone(), group, n)); + } + } + out + } + + #[test] + fn kfp_transport_keys_and_proofs_match_keep() { + let v = kfp_vectors(); + for (kp, m, _, _) in kfp_members(&v) { + let mut transport = [0u8; 32]; + assert_eq!(unsafe { ftr_kfp_transport_pubkey(kp.as_ptr(), kp.len(), &mut transport) }, 0); + assert_eq!(transport, arr32(m["transport_pubkey"].as_str().unwrap()), "transport key of {}", m["index"]); + for p in m["proofs"].as_array().unwrap() { + let mut sig = [0u8; 64]; + let ts = p["timestamp"].as_u64().unwrap(); + assert_eq!(unsafe { ftr_kfp_announce_proof(kp.as_ptr(), kp.len(), ts, &mut sig) }, 0); + assert_eq!(sig[..], unhex(p["proof"].as_str().unwrap())[..], "proof at {ts}"); + } + } + } + + /// The announce keep publishes: its proof is the device's for the same + /// timestamp, it is authored by the transport key, and its p tags are the + /// rendezvous addresses of every other member in index order. + #[test] + fn kfp_announces_and_rendezvous_match_keep() { + let v = kfp_vectors(); + for (kp, m, group, n) in kfp_members(&v) { + let index = m["index"].as_u64().unwrap() as u16; + let ann = &m["announce"]; + assert_eq!(ann["pubkey"], m["transport_pubkey"]); + let content: serde_json::Value = serde_json::from_str(ann["content"].as_str().unwrap()).unwrap(); + let mut sig = [0u8; 64]; + let ts = content["timestamp"].as_u64().unwrap(); + assert_eq!(unsafe { ftr_kfp_announce_proof(kp.as_ptr(), kp.len(), ts, &mut sig) }, 0); + assert_eq!(hex_lower(&sig), content["proof_signature"].as_str().unwrap()); + let p_tags: Vec<&str> = + ann["tags"].as_array().unwrap().iter().filter(|t| t[0] == "p").map(|t| t[1].as_str().unwrap()).collect(); + let others: Vec = (1..=n).filter(|i| *i != index).collect(); + assert_eq!(p_tags.len(), others.len()); + for (j, tag) in others.iter().zip(p_tags) { + let mut addr = [0u8; 32]; + assert_eq!(unsafe { ftr_kfp_rendezvous(&group, *j, &mut addr) }, 0); + assert_eq!(hex_lower(&addr), tag, "rendezvous of {j}"); + } + } + } + + fn hex_lower(b: &[u8]) -> alloc::string::String { + b.iter().map(|x| alloc::format!("{x:02x}")).collect() + } + + fn sha256_hex(b: &[u8]) -> alloc::string::String { + use sha2::{Digest, Sha256}; + hex_lower(&Sha256::digest(b)) + } + + fn open(kp: &[u8], sender: &[u8; 32], payload: &[u8]) -> Result, i32> { + let mut out = vec![0u8; kfp::MAX_PLAINTEXT]; + let mut len = 0usize; + match unsafe { ftr_kfp_open(kp.as_ptr(), kp.len(), sender, payload.as_ptr(), payload.len(), out.as_mut_ptr(), out.len(), &mut len) } { + 0 => Ok(out[..len].to_vec()), + e => Err(e), + } + } + + /// NIP-44 v2 against the nostr crate keep uses: the device's payload for a + /// given nonce is keep's byte for byte, both ways it opens, and keep's own + /// sealed events open to the plaintext keep wrote. + #[test] + fn kfp_nip44_matches_keep() { + let _g = with_rng(); + let v = kfp_vectors(); + let mut checked = 0; + for (kp_bytes, m, _, _) in kfp_members(&v) { + let kp = signer::load(&kp_bytes).unwrap(); + let peer = arr32(m["peer_pubkey"].as_str().unwrap()); + for (i, c) in m["nip44"].as_array().unwrap().iter().enumerate() { + let len = c["length"].as_u64().unwrap() as usize; + let plaintext: Vec = (0..len).map(|b| (b * 7 + i) as u8).collect(); + let payload = kfp::seal_with_nonce(&kp, &peer, &plaintext, &arr32(c["nonce"].as_str().unwrap())).unwrap(); + match c["payload"].as_str() { + Some(want) => { + assert_eq!(core::str::from_utf8(&payload).unwrap(), want, "length {len}"); + assert_eq!(open(&kp_bytes, &peer, want.as_bytes()).unwrap(), plaintext); + } + None => assert_eq!(sha256_hex(&payload), c["payload_sha256"].as_str().unwrap(), "length {len}"), + } + assert_eq!(open(&kp_bytes, &peer, &payload).unwrap(), plaintext); + checked += 1; + } + for e in m["events"].as_array().unwrap() { + let ev = &e["event"]; + let sender = arr32(ev["pubkey"].as_str().unwrap()); + let plain = open(&kp_bytes, &sender, ev["content"].as_str().unwrap().as_bytes()).unwrap(); + assert_eq!(core::str::from_utf8(&plain).unwrap(), e["plaintext"].as_str().unwrap()); + } + } + assert_eq!(checked, 11 * 15); + } + + #[test] + fn kfp_open_refuses_what_it_should() { + use base64ct::Encoding; + let _g = with_rng(); + let v = kfp_vectors(); + let (kp, m, _, _) = kfp_members(&v).remove(0); + let peer = arr32(m["peer_pubkey"].as_str().unwrap()); + let good = m["nip44"][3]["payload"].as_str().unwrap().as_bytes().to_vec(); + assert!(open(&kp, &peer, &good).is_ok()); + let mut raw = base64ct::Base64::decode_vec(core::str::from_utf8(&good).unwrap()).unwrap(); + let encode = |r: &[u8]| base64ct::Base64::encode_string(r).into_bytes(); + for at in [0usize, 1, 40, raw.len() - 1] { + let mut t = raw.clone(); + t[at] ^= 1; + assert_eq!(open(&kp, &peer, &encode(&t)), Err(kfp::E_DECRYPT), "flipped byte {at}"); + } + let other = arr32(m["transport_pubkey"].as_str().unwrap()); + assert_eq!(open(&kp, &other, &good), Err(kfp::E_DECRYPT), "another sender"); + assert_eq!(open(&kp, &[0u8; 32], &good), Err(kfp::E_KEY), "not a point"); + assert_eq!(open(&kp, &peer, b"not base64!"), Err(kfp::E_DECRYPT)); + raw.truncate(98); + assert_eq!(open(&kp, &peer, &encode(&raw)), Err(kfp::E_DECRYPT), "too short"); + assert_eq!(open(&kp, &peer, &vec![b'A'; 90_000]), Err(kfp::E_CAPACITY), "too long"); + let mut out = [0u8; 4]; + let mut len = 0usize; + let r = unsafe { ftr_kfp_open(kp.as_ptr(), kp.len(), &peer, good.as_ptr(), good.len(), out.as_mut_ptr(), out.len(), &mut len) }; + assert_eq!(r, kfp::E_CAPACITY); + assert_eq!(out, [0u8; 4], "nothing written when it does not fit"); + let mut sealed = [0u8; 8]; + let r = unsafe { ftr_kfp_seal(kp.as_ptr(), kp.len(), &peer, b"x".as_ptr(), 1, sealed.as_mut_ptr(), sealed.len(), &mut len) }; + assert_eq!(r, kfp::E_CAPACITY); + let r = unsafe { ftr_kfp_seal(kp.as_ptr(), kp.len(), &peer, b"".as_ptr(), 0, sealed.as_mut_ptr(), sealed.len(), &mut len) }; + assert_eq!(r, kfp::E_CAPACITY, "an empty message cannot be sealed"); + } + + /// Two seals of one message use fresh nonces from the device RNG. + #[test] + fn kfp_seal_draws_a_fresh_nonce() { + let _g = with_rng(); + let v = kfp_vectors(); + let (kp, m, _, _) = kfp_members(&v).remove(0); + let peer = arr32(m["peer_pubkey"].as_str().unwrap()); + let seal = || { + let mut out = vec![0u8; 256]; + let mut len = 0usize; + assert_eq!(unsafe { ftr_kfp_seal(kp.as_ptr(), kp.len(), &peer, b"hello".as_ptr(), 5, out.as_mut_ptr(), out.len(), &mut len) }, 0); + out.truncate(len); + out + }; + let (a, b) = (seal(), seal()); + assert_ne!(a, b); + assert_eq!(open(&kp, &peer, &a).unwrap(), b"hello"); + assert_eq!(open(&kp, &peer, &b).unwrap(), b"hello"); + } + + /// NIP-01 ids of keep events (including every escaped character) and a + /// BIP-340 signature by the transport key that verifies. + #[test] + fn kfp_event_ids_and_signatures() { + let _g = with_rng(); + let v = kfp_vectors(); + let (kp, m, _, _) = kfp_members(&v).remove(0); + for e in v["serializations"].as_array().unwrap() { + let ser = e["serialized"].as_str().unwrap().as_bytes(); + let (mut id, mut sig) = ([0u8; 32], [0u8; 64]); + assert_eq!(unsafe { ftr_kfp_sign_event(kp.as_ptr(), kp.len(), ser.as_ptr(), ser.len(), &mut id, &mut sig) }, 0); + assert_eq!(hex_lower(&id), e["id"].as_str().unwrap()); + let vk = k256::schnorr::VerifyingKey::from_bytes(&unhex(m["transport_pubkey"].as_str().unwrap())).unwrap(); + vk.verify_raw(&id, &k256::schnorr::Signature::try_from(&sig[..]).unwrap()).unwrap(); + } + } + + #[test] + fn kfp_session_ids_match_keep() { + let v = kfp_vectors(); + for c in v["sessions"].as_array().unwrap() { + let message = unhex(c["message"].as_str().unwrap()); + let salt = unhex(c["salt"].as_str().unwrap()); + let participants: Vec = c["participants"].as_array().unwrap().iter().map(|i| i.as_u64().unwrap() as u16).collect(); + let mut out = [0u8; 32]; + let r = unsafe { + ftr_kfp_session_id( + message.as_ptr(), + message.len(), + participants.as_ptr(), + participants.len(), + c["threshold"].as_u64().unwrap() as u16, + salt.as_ptr(), + salt.len(), + &mut out, + ) + }; + assert_eq!(r, 0); + assert_eq!(hex_lower(&out), c["id"].as_str().unwrap()); + } + } + + /// keep's salts: an attempt counter then the path and the tweak marker. + #[test] + fn kfp_salt_binding() { + let binds = |salt: &[u8], path: &[u32], taproot: bool, root: Option<&[u8; 32]>| unsafe { + ftr_kfp_salt_binds(salt.as_ptr(), salt.len(), path.as_ptr(), path.len(), taproot, root.map_or(core::ptr::null(), |r| r)) + }; + let attempt = |n: u64| n.to_be_bytes().to_vec(); + let root = [0xab; 32]; + assert_eq!(binds(&[], &[], false, None), 1); + assert_eq!(binds(&attempt(3), &[], false, None), 1, "a retry of a plain request"); + assert_eq!(binds(&[], &[0], false, None), 0, "a path needs a salt"); + assert_eq!(binds(&[], &[], true, None), 0, "a tweak needs a salt"); + let path_salt = [attempt(0), 0u32.to_be_bytes().to_vec(), 7u32.to_be_bytes().to_vec()].concat(); + assert_eq!(binds(&path_salt, &[0, 7], false, None), 1); + assert_eq!(binds(&path_salt, &[0, 8], false, None), 0); + assert_eq!(binds(&path_salt, &[0], false, None), 0); + let bip86 = [attempt(1), vec![0xff, b'T', b'R', 0]].concat(); + assert_eq!(binds(&bip86, &[], true, None), 1); + assert_eq!(binds(&bip86, &[], false, None), 0); + assert_eq!(binds(&bip86, &[], true, Some(&root)), 0); + let tree = [attempt(2), 1u32.to_be_bytes().to_vec(), vec![0xff, b'T', b'R', 1], root.to_vec()].concat(); + assert_eq!(binds(&tree, &[1], true, Some(&root)), 1); + assert_eq!(binds(&tree, &[1], true, Some(&[0xac; 32])), 0); + assert_eq!(binds(&tree[..7], &[], false, None), 0, "shorter than the counter"); + assert_eq!(binds(&bip86, &[], false, Some(&root)), signer::E_NULL, "a root without the tweak"); + // keep's own vectors use these salts. + let v = kfp_vectors(); + let s = &v["sessions"]; + assert_eq!(unhex(s[2]["salt"].as_str().unwrap()), path_salt); + assert_eq!(unhex(s[3]["salt"].as_str().unwrap()), bip86); + assert_eq!(unhex(s[4]["salt"].as_str().unwrap()), tree); + } + #[test] fn sizes_are_pinned() { let _g = with_rng(); diff --git a/components/frost_tr/rust/vectors/kfp.json b/components/frost_tr/rust/vectors/kfp.json new file mode 100644 index 0000000..09bd69a --- /dev/null +++ b/components/frost_tr/rust/vectors/kfp.json @@ -0,0 +1,2001 @@ +{ + "groups": [ + { + "group_key": "03dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17", + "key_packages": [ + "00230f8ab30000000000000000000000000000000000000000000000000000000000000001ca02ae56653358880f176602958a083c7474848b9cc662182746be0e002c83f502e9387f37978715f5c309d4cdaf0c2848f1f46a7b4f5f563f49452708f4d20ae403dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000023b29aeffe4009d3cf90462697a7634415a91a16020be006b9f1ab2c99c3dc4a40200715fa60063afec7c4ba944780b0b3ed2a38e24dbde3e5b313e078ec600aa9a03dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000003ac50afa962cde1f1e2f15ed05f626044fb5d9b1b53fe3efad6c106120885469403028300300bbe4b483c81d1d84f2555a633516a806aea54ef22e87b383d1bc89203dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702" + ], + "members": [ + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":1,\"verifying_share\":\"02e9387f37978715f5c309d4cdaf0c2848f1f46a7b4f5f563f49452708f4d20ae4\",\"proof_signature\":\"391d1f37123ae5b3cb3b3ecc9a1691710cdceae8465eab5f786785aee3385e2d07d423a8923ac3706dcdf325c81272088fda093571a5ffd7d2febe2010a5a8ba\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791465430, + "id": "4a2414a73b5cc335d81b5f63d0f68a12885070dcd3538a1f8fff5afbbc73e74e", + "kind": 24242, + "pubkey": "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64", + "sig": "5e0d0eaa1cc4f68524b293d37d4089df563092e9f16706a18e093d36c0135bd60d17c516f3d1b1a6591ca3e7ef10c06476dde56a5c2f60a2e318969ec9f58986", + "tags": [ + [ + "g", + "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + ], + [ + "t", + "announce" + ], + [ + "p", + "faaa349bdfbd56b3aa3c4c75bd6e0881b55e62f6cc060c8f47e945670976d05d" + ], + [ + "p", + "b907ea1ad4e1e18663206f663a887cf120831b93ce2dbb59658f2c84a9502404" + ] + ] + }, + "events": [ + { + "event": { + "content": "AjSEMzH7X/Vly9Qw3XSJVhWdIQvigNQfhaE6dsOsf2ayuu2sPaef4u0p7JY9mVXtUP6fqUA+SAOcEflzl+nRS78txDTsBdHaCRgqKpsuG/pp95VJTcBODwVtcwygQjE33wCGwvzuyFbxhlbSWQFqiwmujw5VTv4v6cIOl1h446tMbdCV2GPdTrKk/BW50W0IQoLo5rSvg7Vurv46QnwT3C0QKDhVecPq0ESDyGwd8H7dCVLQx8/6QVA+XC32i/leZXJP", + "created_at": 1791465428, + "id": "4e62eb062dda159b4aa55787dbdcf87e1ea3a3e2a420fb2697272e120727e262", + "kind": 24242, + "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "sig": "bd9cd3d3f3b47953bc7034683dd823ea66f31b804fa8d162174a2bf992d1546267e9c9b278756d1b6c55444bd43f554203582aa848fed5f537929ae0cc2ee0c1", + "tags": [ + [ + "p", + "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + }, + { + "event": { + "content": "Ar4PmTncBlL5fTWOpD4pvHdewaDZ4vTAGG799AaI/lTSP9X1BpDkzTJiJIcWFDOIeNE1c0ufrEk28o4Ah8IVC5/vonDtNsMJsBVzQN3pqDYzhvZkj0YTi3id8pAaoqujf3C/ROAQMZ6ixBFGZfKcVzjIVEBoqcYq1UPpujyqCzBq3o8oyKN4jM1MJ/YVs81273xT8h1aP1jjS/SM7QKPcEZEjFdm1mui3utTUz3bwA2onfJAXooihIfcG6AxitFkUGny", + "created_at": 1791465428, + "id": "e43c1502624511237af7beaaf17f2263058cd7863166045b99921c17270f90a3", + "kind": 24242, + "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "sig": "56d5e891f146f8b61eac8f75b198836fb6955e7e21c862bdff033f9a4c91253026f4e3da19a43215b8872da0898f825d86f02ceb840f45710adb70b5a00b3983", + "tags": [ + [ + "p", + "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"b81364dea51cecb1f6992de21acc5198e4f6409702e37862f20fc640258150f7\",\"timestamp\":1791465431}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "dcf6b6cd32390e97181bf43af7076a3181a82d786504e4ac6531a728c38fbe79", + "payload": "Atz2ts0yOQ6XGBv0OvcHajGBqC14ZQTkrGUxpyjDj755hUwJK/wWZEPvt+ZEWL6W6NeASz+rHRX2xjwqicJyPhObMLmq2n6E35sLBQryD57txfiJtgYqeDsIJ4AnJqOXFcZ1" + }, + { + "length": 16, + "nonce": "48b4b62ce54ec726d14721fa33ea2e6f5ba7b440cd8a312ee7ed8dc97317cd78", + "payload": "Aki0tizlTscm0Uch+jPqLm9bp7RAzYoxLuftjclzF814ZWBehT5lSgqm8zcK66Rnsz4i8e7oKpFoozADYvnQ0OjJoLV/SNr/oxuSr9o7IrS+8Q8BME1kUHZ9LIW+RNIbo9RE" + }, + { + "length": 31, + "nonce": "9ab333ac2c99fb5751f88175a1bc5e9f58d8c81aa2d058ef89c56fb9c0ec4759", + "payload": "ApqzM6wsmftXUfiBdaG8Xp9Y2MgaotBY74nFb7nA7EdZDKB5YHc5QIwMtgN+HlE1wRMj3f/XqoMimAnWIsnuPC/3pvrwcA5Z+KXlt1iO4oOdokN7XxKfvuaBjqWPr0LzKbaT" + }, + { + "length": 32, + "nonce": "6a587cd0a7f9aa7b9eeabb7a7afaec753d742de3aab2a641c6759cf1c4063e01", + "payload": "AmpYfNCn+ap7nuq7enr67HU9dC3jqrKmQcZ1nPHEBj4Bv5EEBYfAY6ifIqhZAdhR+jhKnBBFDkEuUNg1zlNVoHYJrrYSQ8oYseO3vMySgbIiZg6YNV2yQPy3/RVMMj4iTPes" + }, + { + "length": 33, + "nonce": "a7022876b07e89c5ac6df59a36ce873bce8717cdbc5d3b9e2be89ab31db1411e", + "payload": "AqcCKHawfonFrG31mjbOhzvOhxfNvF07nivomrMdsUEemG2vfg/XdSVOPiiXkLUPa28DZ9HOG/jvkQBFp/E4nCK4p0rNUTskUukFLNOqT8gl3ZNr3/bhMiNyPKeNEyb5IELs5TgxSXhpyzWuATjjuIEy/XOxGipuLVxN7AwdtvDpRRc=" + }, + { + "length": 64, + "nonce": "1e18c24039c7407aceed930c4bcbbffe4482506fa0980919601b035c237f6692", + "payload": "Ah4YwkA5x0B6zu2TDEvLv/5EglBvoJgJGWAbA1wjf2aSzQuM9i6fywHC9tqZGvJQrq8nltrqjZSl4g+lbUrC7bBs8vDInTWmCcV+kVbfAGdw62xZ1nnWIq1w2Sf5mS9V1AKC203vtEAHbJNnVvy1dq+zeyfDn2KaD6g/Itf9x/MkXUU=" + }, + { + "length": 65, + "nonce": "23e76330d01ad81fa02cc808b8b7898bbf56bcbdea77538c17a634f00909c7ef", + "payload": "AiPnYzDQGtgfoCzICLi3iYu/Vry96ndTjBemNPAJCcfvCrSINNEyfbl3dUq9niG53GzX0+zRl4lGuBktReqFh6VnpcTmeTrDQL3/8vPAzskDa3lUvvmz+YlNOEcuWwDGNC9SnPFtsPdvc0saDjWG9zTMG8p1r2B8jt377pLMye94IY2IR59Qw9PAQFNlQ8I4EDQoDVRLlvc4qurkgELmkkuiwQ==" + }, + { + "length": 255, + "nonce": "a45a569d10dbdbc16a553ec39e7d57c7ae373d5743e4575c939b7af6286194c3", + "payload": "AqRaVp0Q29vBalU+w559V8euNz1XQ+RXXJObevYoYZTDYbQYWM2t0mbRljDvKPIbmn/PSvEh2ADuf1NQpeQWL9/QGXz2kYYA6vApTwtum0ENLeyBs/wez0Bow3qYEFYHZXtnkB6MbQlAly3rWcRSzbFk4raXeQ0Xj4WsFNVR/9C6Y9G5Rfu9xVWhudkg/tF2zhY1Kj6+XCNk2xo5cC+NitTx6ttK9GxgQ7WCts8LP6ddRpNSlxGOPPsQOgdW1DsH6RKHy/MFbCSX4snuCB7IrINEmxuWWc0PXGqFUHsWWz5S1mcpvpkSHpbE0P2hTf1u2eV3AUvCT+aqKf5GrGiqRX69cfK/q8F0yFfUkiIHSRQ2vlC1if1wn6SAtraIf/zwvlKTL5MuurjkQuneOUS44/FCFIdHE7wfWkAFhmP07UzuRmc=" + }, + { + "length": 256, + "nonce": "7a57603ffceeac0e818711589991e97122d189d97482f8ac65f5419b3b8d8ec5", + "payload": "AnpXYD/87qwOgYcRWJmR6XEi0YnZdIL4rGX1QZs7jY7F6KvJg12MpX0Cjaerv0iutGca5ZlvOeE9e1z47y0/pDcQCrHFBp5sE6kXuhD1wcqY4LczEfg7nKNRoMFfUuZU3VsB3t3h3258mEMseVRafgug17xi6qW8/k10jKOhweLVrDerIjhIRcwomF0w1g1HNM1Cvnd6IPMqODK2K63HNl0JTczw888tASmaFkZun7AAhGeVUjLd5kwrF+yBUeZaI39SapLDwZoxhZFY1lT7QDkxzk13eBxUa02lrlGwPxSrIwIacOw8zwiT/pvjSjEDW0ECaCA0wjeJvdakeNj+Z+Ih1eNwv462M3gQwoedTcA2xA19dPtDJNyPKdpgcZ3pahROUb/M9eRjbBfVdoNoniW/ER+JfuwWT2ebGPzG+M1hrlQ=" + }, + { + "length": 257, + "nonce": "fd6bf9705d1bfe6d0eb64e0d4706a79c6c99d072c7cbc7f7ffd49361bea39e69", + "payload": "Av1r+XBdG/5tDrZODUcGp5xsmdByx8vH9//Uk2G+o55pJV3ZDrZ2OXFjn4iJnjGdbtIRwxNKZuHe2+tfQzk0ljI8gIxTC9fk3HkwsjL810/w2+GYh9FN5te4VGJhdgz63VdoUwgeeHItLmKcUuCWbKanfJDbHNkNopi+UJqP/JmVLpT5Z+nWo6u3ahoASnkyeCri8g2AGGoCNxjt8bgrBwK93clSlEWNw6m3Gm6t3t+LwkudIyLsCpGtijV/oPiOBoUOBCFY/+5ebpBRfspvaM97TJxScWtwGqWL0eu9dYxhuzKF2Dkgx+iC3NCryaPSXa0Ttwzk0O3toA0p3C+oJA6hDLwjR+WlMqkUxE088UQjPl1jzDckjC/n7fN2/uNYdxAyvWc932ex3RGzNjYcU5sfn2XqfQ8uU7/YQiniT8CYXKKPkVkjnEcqwPdTsBYBkyEgB1myDPLjw84IuQQHw3iM2R6wWq0ZazK7/CBrUYrWH5l9gIM1D8IR/Whe5fbczRd9" + }, + { + "length": 300, + "nonce": "8aafaa2134326197d827571d8f2052d6115065a0f309e1f80828ad3064622ad7", + "payload": "AoqvqiE0MmGX2CdXHY8gUtYRUGWg8wnh+AgorTBkYirXjgKRmvGA1BhEWx8QrtjkLZB7hRqgxr/nkGfWGmguaT/M/SaZsR9XDlW9MpghI3KtnkaKHYVJvq6brEdnezVs8wvF7tfJoLnXGfkg8t7ae5FuYTPEgGwjhBoeTnCjHac6o04ErbmpG9SJfm1W70XuzczBYEoPsjyUT0lhiL8ADkiTqdfYd7vH2iBt0c8shb2gx+j6cEME6OfGGj1Yv3Bu6WW0j1L2SWarTpDLmST++J7Eru8Gg1pB7z7ox9GdqaydIGK5ROjZ2n20ol3UJnn1oCf/xq8a7ZhXocarsUW5VKKa2REKEHLWUdsR7hJgbauil74SiGXIrC4sg05Amm03YF4o961mSqlkoH8sY4bjh8KIJytrrnY38BlsMr4HpDR0lq3PBpbrqbpF8DvcZ6xgBZALMcU3HzZUH0VkDUQf/3gTO8+0e6fZPW+8jiqFdZenU8imGuLiO61xu2gFdMG8Q1lS" + }, + { + "length": 1000, + "nonce": "f8d276c0db3eec61f9a59e58096f89efa0a9a1b59579ebbb4fe3ed5076300657", + "payload": "AvjSdsDbPuxh+aWeWAlvie+gqaG1lXnru0/j7VB2MAZXJoIfZPlCIX9ctde7KNNJECntPg1Fn0CrvnKZeOnYhpjn2vnuOW4axF1Aaj2gE0NISx3etPHPnATeCF2S17M5I6WDETNl00v2WXnGceKir8xTaOPvnKS+iXdtAapGds8ZzBytj2OFvNvN8UMYyJHAlB9R10FqTHE7dWbRapva2D+aLRBmVClN7MyPuMU5/9v30IF/F+5AEyTIglL2SkT6mDNrN22qE7gSVPhkDKYoZdpvuCJk2OtC4QIGfx9QcO7aDb6w7+AlmZ4Dx8uZpwUOZrqyTrxrfQcoDHIuJ3vV/TxCqq0O4+wT7PsRsJQWE8o/iDrSyONOUEa6Njoq7Lp3xEQ9gm/3zxy2SWRKW1mIIkQYQa6+TG48WaG2EsdB31TXzkeu+TA2og7cwXAYq28vFvuKltuckrbchPAoPJFqx1HOlfw6Hy4Sfeqm4SKxpfEbJOAag/HB6h82/gsnGBrEd3bk01Z6EE/Uk0TJUj9fLCYEPXBU+o7GWXQKIIpX5YElcKNiL4qbqSRAoMcVQXXidRKzS7AC/lSUgzZauXDcuVFnsGUjcMSkwMAjNOMgI8X1HdDSso1zSEotGqK/x2zj91qq0acORykR8Ma2mmY4MEemhwAi+57p/MGciiW8izzF48hNIeZ7MiNL5A74K0StPGfHpDt01KJAM4LWXl9jzB1JTi4imbxLxb328X6N+a+y1mfTQd7Me9dyKOIO1HCq3oebBYJ8iBM5lYqMJFeskIQ7jrXamBMYJyDXkViy6EzSLbWJHJWLSLR50+s8rUbgofAJwoZil+r3GNw/PtNEOYNe07A72ZaKKOyPUsCbmpJQQaLTGohGYNRJw4pXrmC06+USxoK/KbV9KjdNF2aay0iVIG1lqImkQSrP9zDVEn+J+FO8Jbf+BRm0zMxeNLcJCvgpRWHyUcml5TYOR8B06UXXiA+5Oicn9biSLf9gjJ3qvnquT9kkwwhlTfxuwkvqZfM42WImWCtmQrlBjJe7HKT0IKjxeWlxpoyLFX+lDlBHQFoqEV+xZ5U2z6gGa+Ir+JSevJ7qq65VdPs+exHK1iOHU0Gw8IBLcy/zX+inB2L+6IGVPHBdDR1/mSqkH0IKrxWZjLMkXZB1JLIe7p6+x5vyZ64kDoDSSOJdfJQPT2Uq4r74/ZfwunZBZV9VDp3J3nErsqqfBAgAV2agrAYdUN/nhNhrtu6u7JZB1sYM00sBLhiCqJB31YRoM+v7qdrlSHKBTsu2s6FH10IUU4dDJ5k0yb6BLd92TnXaqocZrVRW2T2JX1fed+6yMel5w02FXb2X3Zb5zLLdfL2XWZlNEBb5KR73VZZue1Rzxvy1AMB0umiJB7eFblJmAuBAv+fQge+Ebq/Ci6+RTfbHl7Cq7OMXPfHGHjr+btH5/H+gubCownY=" + }, + { + "length": 4096, + "nonce": "6a65f86b1f120723d8751d74d937dd490bea1ce61e830f3d05d5c6632d216697", + "payload_sha256": "6db9d0069a871a1f9377ffde58a40d5b2c5cef98e04e87db12d58bd0140b27a6" + }, + { + "length": 16385, + "nonce": "8f463a85648ea678abb43a6706d9b3821d45b3f68584c9179399de5277c555c5", + "payload_sha256": "562e432b890a2a40c4591a14bca67e28eb9b5daba4ca7a30a83852ae1e2d1f20" + }, + { + "length": 65408, + "nonce": "c2c2c44e23f42580de972f3c5b607e01c8c3e5ccd50720280ab374150658dcf7", + "payload_sha256": "f05d3cb541dade55466a3ddb19ca10c068d2f815ef49a153cde6e586b904f90b" + } + ], + "peer_pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "peer_secret": "152de0e509e2a5324b88f1286ba08b3206243ca7ea574672f7c85e2143341df8", + "proofs": [ + { + "proof": "9eed2417eb3d57799e94daf2e7743753363c0ff98c9d82384e071b4daf3272f4b6061d7f266728f095588d6ff10812e11d93bcc38d3d2cbc770908e892474e74", + "timestamp": 0 + }, + { + "proof": "cbf85caf83d7ef31d04d8028cd2b2da086f984525bd309664488cf5b49b6667928058ae3f075b509bdf0917fd666b4e64086ff3f7409fce6ccf552e0f99573b3", + "timestamp": 1700000000 + }, + { + "proof": "d4cb9e2a21d382620d67b96523961dc21d7946f5b9af5a9ff76e429b9d92a72d31b2163f610a364156003259d14492d8a813b8c8529c77155a7e0233a168c13d", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":2,\"verifying_share\":\"0200715fa60063afec7c4ba944780b0b3ed2a38e24dbde3e5b313e078ec600aa9a\",\"proof_signature\":\"26337784c956f0ed4176de32c5906b0c3d61e5aeecac5666396aaa2bc6fe19db60cc4ecbec7cfed8dc2e60a7610ed795a12aa5cecc993e10c22c31650110cead\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791465431, + "id": "c5f807ccf9e0353b668c625199b3e3c4bc07671e5c9d5153e015b662f6cbfc35", + "kind": 24242, + "pubkey": "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07", + "sig": "107475e56797bec6a0adcd0afb6cb8b7cfb8962e128bcc273929214bea7261e1faf4c707bafc74ffa4dbc3d3f6d906ae0d134ed7276098d6ca5a0b2944cbeed3", + "tags": [ + [ + "g", + "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + ], + [ + "t", + "announce" + ], + [ + "p", + "357fb06973fe9f1aab420064cae67d4a08bc94b9b14c277a2bb4dfa78c3ca71c" + ], + [ + "p", + "b907ea1ad4e1e18663206f663a887cf120831b93ce2dbb59658f2c84a9502404" + ] + ] + }, + "events": [ + { + "event": { + "content": "AqNlosWO19lYetgEYJuHyLNO0IaJ9lHtTQB7YwgLzOjkpgg8EVJrLQbT2JQ3lEh4jYyXw9smjocurwzz+y+m8elj5SxCSxaTNIc31/b2jrsmyYk532/WDbyN4uaj9eeKlxEssKIwoN/AKFzyIkB9dv1LZTHqu2zqNyq6GOGgVkl0OujZZG7E2N/DtWOZCX7JV33geSSznyefyBzO2+tooiNDkU7Ux8ODnPz4k/vfiN2aMnTzT+su3bUk3hGqRrF5z456", + "created_at": 1791465428, + "id": "03e3fb0a2f8e447be7604ad8a1e233541022baf373c227a7f9c85c3ec20196aa", + "kind": 24242, + "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "sig": "7759bbdc94702deadcaea61b2e1b12e6f9ad7afd77af257f1ac220c5892b0630e6d5fefb6402cfbb40b8c7521c15e07b725b72cff35765623671caf1e211c4a3", + "tags": [ + [ + "p", + "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + }, + { + "event": { + "content": "ArbSQLY4qBxrdjLhkR6ST1jIndp0Dj7oX64hY2dcTuLPF2CeHG8g9S5YeotGateVEcdRhxo+jRWBj7vpOM+BvdDD5C94hZiEMbcGoPbMSW+fzQU46GmRsajOAWbZU3ffrL/iqsq7DstwIKTrj6o944bC8JkJnJ+5o4xXIiDYAeEkXxoELnpDdX2gFTrq2XEGbhV5NZxlQdfUzl4l2AyONcKAOKkUJ/RH/Cej6GKj5wzQ+PgVOhxIUp75s+P9rGqixXSe", + "created_at": 1791465427, + "id": "3111da328e61b6621dcea9f90455e92577802f71e425ac68af1a1c2202d12349", + "kind": 24242, + "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "sig": "b403db38796111311114ccb6e57b5f8f3835b780ee9396b01cd92a1380e7aef6ca87942d43c8d596aecf8613b24832ff403eb13708c5dbd642edf906f9d9235f", + "tags": [ + [ + "p", + "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"382bc6222087a6a97bd562ea63b8d78e7c6bd3b0e7ea7a85205d24bd3a77150a\",\"timestamp\":1791465431}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "b8f2e6775f251ea98d6a8ef5a5f140643e479defc638cf0b440c0ad3a9106295", + "payload": "Arjy5ndfJR6pjWqO9aXxQGQ+R53vxjjPC0QMCtOpEGKVwrGICULEWi1H8SdG/+XE1EYPxQxYJqa8Ql7RYlIWH8AZ9eJ2sx20Zgabifw0pgbaOE7FuzPoIL5x/ayb9+VgOEtn" + }, + { + "length": 16, + "nonce": "c59282b26cc46a3f64c4f96f988b7becf299e64d74ea5d174327ce6e043ffdbd", + "payload": "AsWSgrJsxGo/ZMT5b5iLe+zymeZNdOpdF0Mnzm4EP/29tj+H/kM0RYeok/TQYj9ytATrwc7QzJjgFTgb8qddeAXD9xyVlgur/YvBxu66JLk+mn3xum/NTU4tgW/jPdtx8q/w" + }, + { + "length": 31, + "nonce": "829f8e09d4ff7eda8329d644f651c604e52adf12f4d58e26ae85c89134a93dee", + "payload": "AoKfjgnU/37agynWRPZRxgTlKt8S9NWOJq6FyJE0qT3utwsuNYhjOYvkbsVp0Y7sIUGwjNUoOXaugHl0hGwk5/BniXjkmBLMj7yAwnmPArku1003tN3pT8OyiiXJamjqFOtW" + }, + { + "length": 32, + "nonce": "603e01ff6080e2d85edd38c40a87e939f406e01b805c0a8bda1db501ca23c63b", + "payload": "AmA+Af9ggOLYXt04xAqH6Tn0BuAbgFwKi9odtQHKI8Y7OK3veM1dwqc8jbMdjh6P0Ef1zyaxAiMnyWmW6stUzU6ZQ2FBILeuc7x9hTw/fgrK6mnpeB8GGZyktjPCfg4jBrBe" + }, + { + "length": 33, + "nonce": "d7c37b8e99c723616a572094952bb3e82562aa473e2dafdc6cff37cffa21195b", + "payload": "AtfDe46ZxyNhalcglJUrs+glYqpHPi2v3Gz/N8/6IRlbcqvZy7pwpmtlErzw0Bs9qI2/0ux5wv00AUtgFpLF6CU4cSMa7VMncojkM2bKHzJiM2tp6ZNdgxV9c0PLwwmyxFERG6fJiQDe2g6gTHq9co6IvBzrlx+u6Ehwzwh4g1q7pvk=" + }, + { + "length": 64, + "nonce": "3508b7761c647e03af690a3d0264796891b366797408359d6e7dced38041e1f9", + "payload": "AjUIt3YcZH4Dr2kKPQJkeWiRs2Z5dAg1nW59ztOAQeH5ZH2OHo5+o1w8eN0I6ir7M/SakfKYKuO4YvIrPkdxRqJFhb5s64MR0UXQZom6+pX6hfhi6j0pIQkU8kwheab5lBT80Y3CgtkgVbaN5sDdXV/wcWfeCpef7TPfe/ec9a7AXSk=" + }, + { + "length": 65, + "nonce": "9cbb46d702345d74fc1e62fe7c8e98ea8d0663eac786aef2dad29ce442cb42f8", + "payload": "Apy7RtcCNF10/B5i/nyOmOqNBmPqx4au8trSnORCy0L4GdoeFS7DL8IVvdGJ52XUkrYa6cMjSYtzuygb1150znhcjxVmzuppId1yduQ1i98U1QW3q/mOPFj/Rc0i7Cq4z8tHotnnWgcCpYYslYVPAlXl0KI8HZn/VS6Zsr2jr2qnpOAba6gy20DuWuufTsdfsdMuFWy44VfoHZnUAZNsYp6QgA==" + }, + { + "length": 255, + "nonce": "e0ccd25f7e14cb8d44bc2711fecdb5a764f9ecac47f4b7b622bd1bf4ccf9bff3", + "payload": "AuDM0l9+FMuNRLwnEf7Ntadk+eysR/S3tiK9G/TM+b/z4bGbA2E+MRQgKBck+FUQ7s3mJPYpnzfiHPLYsOheeeRtFU54TgMmxgYHdD3XF3IJHiREUuZifnFwPNwd1Minlsi8mLnAHRzVE5VrRoBN9O6WNTE03odtAYBG9l5FjnvmuEcaNO1hhHh2QLH51Trt3nTUDbKhZeZNHKsf2HOTaCovO+gUsqqEliFKyBQyj2UGg37dUGLDH4/JkWikyBycxumxya3HnGLPnx92PINWZZyHUPa4Hn/uDvgyvQZIMUFOsmFWOJCZlfYRYV8DPEP00TVaTQvz7iCdeDUk3l4/XnILp9uvKvN2TwuoYowuxLEPm43/9EPiVdYnrSzJg7BH9aB/hvpgtq83VQ9ISIEP2g6X5qQ/wXwXSo3bmwEEiVHkkZA=" + }, + { + "length": 256, + "nonce": "e9cada0b5fcba2a39654121ceccf8779326057e56aad0057a908fcad2b2cb86a", + "payload": "AunK2gtfy6KjllQSHOzPh3kyYFflaq0AV6kI/K0rLLhqDj0ZwlmrgNMKZ5RMBU6MxEjUiT9tp/Ud3tcAPACzZSOUmCdAR/UovjNNXqCyi+3S+NC4R+2GSz5idP0HaKBprZg7ThkcWzm3XgfQAsMY/ZBrglKLmSi0kzqzhKI66xjBWReAK6kwj6ZitwkiKgftHP+XHZxyFcvxBXXz/tf3k9YLg2I6bbNO27zzsdfREpLXS3AOUqLB7rc7p5sc0UWhzrrYcX1+aEUvRPeGfB8IQnEKtix7QvrIyto3LL57Nz8dHhd0EqKmDPubXIu6xNwRHLeePX4S85xyQQPX710MnjU4McNS5r4m3kL7M6o91/K3wWJBd/CvnTaxMtiHBiT7sL1FwJRTY/0EmhMMHgVuwPl1X+oV+apFGFfQIvhtZghkMAQ=" + }, + { + "length": 257, + "nonce": "236ab2c2ca02af483d14421d1a7544d3d12b345a895379bde5e0d37632318990", + "payload": "AiNqssLKAq9IPRRCHRp1RNPRKzRaiVN5veXg03YyMYmQEmAYaFE6yYGlW3ebXH7XQWhy3lG37mTnW0kxG2yK2ontVr32GsviiBzUe2WmVrjzlX4Ow6f7rKRxVAFBbAXKOW5OW7gVVlZl28W2hc0wxAsGxwwm+Q8DlKZYu+27ho+1MpuRH/hBMOseJJ8H9qGyftC7rGMX/ZOXT3h2qzdhXS75hs2+8TugNaFcHP1Ogul2Glalx2ZuU99TZX6dIZ+QhDmJ+CiBN8G8rTKNLUZFZjO9IxBewWzEyhhEZtZQ0cPBV7ZI4HAG3ffxViP8b1APfSjFzcEAaGbVMJNCqSEC/vso9zDgV/atbhmafVU+B03MSd1VBFeFZZ1hM5yvoPIc01Lub+UR3jOIqidQJgWFpKlaSj1Xh/rgHmB51WVyWJEKI/h2Huj18IWe6lDSRa3fxQMV/lz7Gj4XeZhUDBWxt6jjDjIiOMfmh8sq3EFlwSGznags/n8LL67Pisof2GeHSYmR" + }, + { + "length": 300, + "nonce": "64d384796bae1277fae95d440124e3e024f42154562ebb646731d9b00d74b826", + "payload": "AmTThHlrrhJ3+uldRAEk4+Ak9CFUVi67ZGcx2bANdLgm1qcXDcct3ycJH5ROPxX3DYK6qaiZyDFyrSoSD/9E+Qi8SdkzCVwyw7kxidaMsQWq64LFsDWJfGYrXr9LqWkPwlqrD30IjRB/TKytaSsJetyyZpxEoMsW+W/+DuZEVXv79gnWwkLeDVM7zvnyHL2pBCJzKU+Nxt+cWvqWbV7eDKzuX2xxSK4r2bBZZyWt0NQEAfAVl0R9+BaF8oBfCfv7MtIvj9fe8tkJYAmfLmYOiFGEDSY4/zBsY2eiSK4tpQKJcgYm5yLBSqQKtV0cSujGXCRCeNP2rMXn6SP3LB6jDiFX1JIrJiO6cC3lXBSXlCzGBXMLWwqkJ4Q5l343k9rvfk9iAA9S+vuPRDm2FmOIs+VdwtMLEFZny//PrQDRShR4mghrMXty5uZN2P0yjkIF+ItAg6CiWw+POK3bVbUol23b6jQ4oi8AnlzazBlvv8YdFjSBeBrnqmlEgO+mYUM3DZ9J" + }, + { + "length": 1000, + "nonce": "6d4e314c39aeb7e42c44525a4417dc4cd08114294fe22a36160c50df3d5a4bed", + "payload": "Am1OMUw5rrfkLERSWkQX3EzQgRQpT+IqNhYMUN89Wkvt28ZIi31msLvSE9qxgoeYj1bTUhQaOtfk+Hpkd+9dCguNvcpo+iMlJss/NWCFxn5Asj5qtixuxinP7sizM7+1tO7ue/QXTZY6LGiEZnbF7m6smM4ZLcQoRFzb6Ju2D+rAEoyy23vLhlnxT1FXK3/OpWuPhFSjTP5cjc/s2P2U6XQOUW2Y39XRKO5payBFUzzQZCfLKSL81aG0PJ4e2Jr1wUZ2nkpE2Wi8g314mvsz7IPxGRUFcZkjEd7bfSLr/SlhWb9vj6xPVYYiORLKylCvy4oVmslrPuV3Oi56h7UrSe+a2oGtFrT5mJOSaAE/LTUutoIBE9dbROmkHcoxG8lstxB3uzPlm9P9IPHS+dO46wI9Uq94WqEZAFX4DCuVpIchGUHTJF/6f2F1W6RLbygr0c6EhF22pxTksR0FxRxYaOuD3LiBCvJl4+6ePbxbjQtBuTaF+wWg3pj0kmVOjp7D2Qg77Jl+uYo4DneQH3vdyVMKTxFBUvnRb5c6ZSQCqPTDFneRG4wfDPY0J4Qs5HudDZkuHWcbVE5/ZGbRVcaguugK2l8NgU/x29qiPpwRH+qpwI0eQYvg6NKFYUr96qEbjQb7VCyWcaWba1cZ4CNziBU7suR+o/wR5YQfRCt8OwrYYHyktdgik7sm57JYuK2sqeOhLs1R+srGGFAjajLXnIEbLjUMjqHBxrWc0NDGn6Ea49NeY3tKUtuFBISp2BTd0GOJ4sv40YQIWizbN/VnFE4X14TVaxXlPtPiO8mNyRsTYN5Rump/LqTCh0WkicAgfALc007Nb9um+Gln+hbscsD2QRbv/JjV0NsjRhe6GM3nm1DT5iD3oaFkl/GY3uRxr1TQiI4WXQ8SEA0yEhMJQcUDqvFpAarcdiijwjTYO+jNjUEGLZdDfF+v3xjZSr3gekYtEujDbEIKbjBR4uNBwh6/xRHU46ORozsQnFR6wa97udgICpmAThrTKa/iXhKfg8tWZyaSgO9ddmu0EsGJept6fSNB7tYdgk+nZQSRcNqt9h5ZvyI6EvcnMEBfdRTgfJ8byA+E0WU9G9tj2o+OqpoxWRMUSizh/KkDk1qrUiQHZRWmdbl5seEzXOA12YgXyA3Ajz6f7iljpdK17FJsCHnlkKiv2oszqzY1iEdzwpVHl8274Kt9arvVwNjFmlFZGd15LkEGgMt2QkQTv5PU0Ks9S7YK3sfJPm+EVQhnmeubJqjmQStq7PuUwE+/jPH8YQqHUaEl7G54HfuSs0St+U91Ia/6ZNGxWnldy3VRX0g4GGWp3l3nvJAKM/CUV9ITjSerLtkC9q2Fk7TYOGEgiQJxnINdn1XRinLmBWgkLBA85l4aIg+Zho7+C7d2S37m5JYphV+p5KJ3OYhSgNLisHSla5N3vYCwDCK6C8WOF2ZBCyY=" + }, + { + "length": 4096, + "nonce": "ea2fc87b3ffe89ff97b7c34dba9ded0b72a9cda90eb5623708edce2cbcd96d39", + "payload_sha256": "75c77a17bae7cc7614bec3be25c7085b5797ddb287d0a399f3510930178203ad" + }, + { + "length": 16385, + "nonce": "ac23b1e608d8809557360341fad3fd434eb4fb7e3ad8b4adc57d32f04a4152dc", + "payload_sha256": "9ac981ee461bc2e0b73a988347c7fef7b1ef7ee977179c338c4678b4f00a501f" + }, + { + "length": 65408, + "nonce": "69f405d2cf1a3ad0c5dd6c06fa841c0ab192cad58180a9bd961cd687e9db3aa8", + "payload_sha256": "68036cdce1f2774f630f925606e8e92cb3ef7320cdf4d16a1953a1d566ed981d" + } + ], + "peer_pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "peer_secret": "d08057dd8ce33af2699b9a44549e2b6ef1ab8bd3c62c4f42bf129065b596d920", + "proofs": [ + { + "proof": "6b2100d00060dc7fac20a43e2777322d3a1ee5cfba4e38c200e7a8d7e96ec28b0a7c9dcd3520462bb896959d9f2fc1a3fce83854fc05c49b777cb32697902066", + "timestamp": 0 + }, + { + "proof": "9efc87738e2acf121210f9220043e5d180b90a0478200a80da1847bf31f28abe691d007706b916651aaa4c7d21814bc1261bbcb64d25d3520791e2cc5a61ccba", + "timestamp": 1700000000 + }, + { + "proof": "9db62dc6acff746806b6d3fca11f47039afa19ea90f85a2b7df5391dfe311f851706db0b9d6b213025fa4324573e74a49ee614f67918db2fdce4d96707038e3f", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":3,\"verifying_share\":\"03028300300bbe4b483c81d1d84f2555a633516a806aea54ef22e87b383d1bc892\",\"proof_signature\":\"66a806fc73da48cf9e9f0fef73ac93bcd796b510cfcb29f1f39c16bf79c145cba33ad9dbf9d90d6734e77a9f2aa0bb4361b25c8d8673305edc24f2b88cb29288\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791465427, + "id": "7520adc34a99dec1f91924b2af2e57af31e1da49ac8609816b6f76fc4bb93ea0", + "kind": 24242, + "pubkey": "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57", + "sig": "35ff262f6b568e9b22427e1b7eac49cd8e8de588743cfa05185537c747ef5184f3bb0a195c985d30cdada518ccf27de9071ce2ddd843315b2e4bafa12f6581a6", + "tags": [ + [ + "g", + "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + ], + [ + "t", + "announce" + ], + [ + "p", + "357fb06973fe9f1aab420064cae67d4a08bc94b9b14c277a2bb4dfa78c3ca71c" + ], + [ + "p", + "faaa349bdfbd56b3aa3c4c75bd6e0881b55e62f6cc060c8f47e945670976d05d" + ] + ] + }, + "events": [ + { + "event": { + "content": "Akyp5ryiFojxqXRpZy0vGR8finAx0CByQtKr1l1HqA0jX5BgZ3MB0U3yjbGG7cDOivcL71bIcvAQkPvRQ5PcvfcQiB3Usw120Zzj+xYu60ooTkaY4Dq2I87mfXhlyUKhztQbqHsE9dlk20luH3PvaUYOw1RsHQrsjD4q6wmOdGViPnsKyEVZ6GWVKO+miFDKptJ28N8AUmLQcZTTeDCzh5XS5huYQ5J3DQvYNZh7u0XIyWehpUq1MJHrgCOjtI0vHy53", + "created_at": 1791465428, + "id": "88823ead71ec30efc22b8843b2e27ded2feac26b48da0ac503548369877bc8e0", + "kind": 24242, + "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "sig": "d6a9aae71c7f495e49d0f9711a9f6700f8e3d9e2312f82ee0b03e608d00aa05d77a30bca2f26db80b899706c9821805c8a239a00ced7a7778ad2f9e4d3d19733", + "tags": [ + [ + "p", + "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + }, + { + "event": { + "content": "AvPa95m9CTMzMDYpZVp7uxM2cnDyXmXmbt1obw1uCv4CokR7J4bUjTVo5pH+qZQXIPyrJmrOlnPRmPwb0fIB5IIjKM3zLza9IJ5ka+cKVh46h1uL0yrT97UfR+SDgXHj5TnItbbGq/cF/L/Y22cKxcet1DIdHCQD9a5G2fa8sTuFwj42dFd/V3QNbH96HJCCN7eJHSfqfDgl+BDmu3r5xG4t2objPi2ISbQsB+M6xp8GNltH3MaDKBs/GTgYEVGY5Vrj", + "created_at": 1791465431, + "id": "46a5f8fc26d67ff371b7a8891d7888980c9374b7582046992df03daa8cce8264", + "kind": 24242, + "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "sig": "85076549c7707d7bfd4cf9ac787a37a5970bb050d17f9b89d64117ded19d40de9550dcce795539bad7a4c5a30788bb12aa3448d682d9f72dac8d2294da415813", + "tags": [ + [ + "p", + "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"b15598b5986ed1a942702c5736e8131ad209a9af3e8999bce6b2f677ffcd6703\",\"timestamp\":1791465431}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "9e2a77c6d673d6d7bf4867ae2e21a690e909a969862da7cf69f7c1ebd21557f5", + "payload": "Ap4qd8bWc9bXv0hnri4hppDpCalphi2nz2n3wevSFVf142WT+fkO35qb7Lbf0lTMs39XFlBklP4dq1vzVRa51f4E06edG8/Abopea4izMK6uPHS1tHRT44lzFhz/Kq3BSptX" + }, + { + "length": 16, + "nonce": "535994757130a18b2a32a9cf97f5e0547eaa34085f3ad74ada82cd2f636d932d", + "payload": "AlNZlHVxMKGLKjKpz5f14FR+qjQIXzrXStqCzS9jbZMtQ5SYb1PfO2m2/a5oB/+KuRBbFsjEf8mczSPJ0XPNN/2sgyHHEx6VSrzTKhQPm1HOf9YV4Y9lriq9ef0N7/svNxGG" + }, + { + "length": 31, + "nonce": "05bb75660c644972b205a0483897cb145ffdaf56ca87d91a24895897172fb6f9", + "payload": "AgW7dWYMZElysgWgSDiXyxRf/a9WyofZGiSJWJcXL7b5+Tngt/9gz8c8O6KfD+Ry5a2lAwxqJHcPbPr0i6EAj38ovWzyjBkl6ISOqafY35izJ4isMuc1M5xEVUe+sNKo1lhr" + }, + { + "length": 32, + "nonce": "3fd542f4df8fde9aceebe044cf9d3b1bd856c4f5e41e3208de1e538cdb7db141", + "payload": "Aj/VQvTfj96azuvgRM+dOxvYVsT15B4yCN4eU4zbfbFBjMQETLT4dKIXce+LMDzjXhM646d1P7wV4uo+5sNBiOZVEADR+2wLysoC9eg+iNlFkm45Ox7qe81HkINM7FHhg7zh" + }, + { + "length": 33, + "nonce": "43522a905753c2e7b53d5cfa5d24b2b26ad302b93c728673c7cadca254cfc923", + "payload": "AkNSKpBXU8LntT1c+l0ksrJq0wK5PHKGc8fK3KJUz8kjNUp1OaslQ2dWtIgao9g5CneUiuedw20rxRZJR7A9ibB012bd17Fv0uFTacqTW+KscbfvOTTsiTHdBLNdKbVjK/LTmA8ecH2/kXMA0jFVw66CQrriDxzULxlKb1n9yS0b31M=" + }, + { + "length": 64, + "nonce": "87ee9efce73ded10d6eba1295eb83799494fcace22215dd7b3ca39e42663b501", + "payload": "AofunvznPe0Q1uuhKV64N5lJT8rOIiFd17PKOeQmY7UB0iw2pstU8PTC/k8s3xI/UZowM93+75DqRl1YC1xyB1sL8GsRvaOPqCoMyrqsPciKYYDw+gd4sdgQqtCLtgI2rGzaIik2xnH62DPsB7PwVwI5TO4dcIJBIqqiyZo2kvrfx4o=" + }, + { + "length": 65, + "nonce": "e682c259fb54aefcf20272bef0677b1a0393c2b5ace572e2f6e2d27c5b3100a3", + "payload": "AuaCwln7VK788gJyvvBnexoDk8K1rOVy4vbi0nxbMQCjfKuA6XnSkNoeSDW+EAzx8oTWYb0Y1m9QR76/DCT/id+JThR6CvR/ti7emjms3tYifD1bURfyx1QzJHk2kTJY8Zctv+zgUVgdlAtKcefwUIljhilSAwlwMbW4Opu3UPO3cQw0Op4/PTjDEV3oGdoLr9VkOGxfw489/JeWcQPYYq4Ydg==" + }, + { + "length": 255, + "nonce": "e88ccdff56a18bb1f04c786a1764e06a4626cf4e5f73aa7b3f8df409df1823ac", + "payload": "AuiMzf9WoYux8Ex4ahdk4GpGJs9OX3Oqez+N9AnfGCOsw0jAm04N1zQn5qQmIcIZhm4+7JP8xxffTh5B1aLob+1lD5O08qpOlHCwn7NUJR0Qk91ny+p0GO5zdLRydLonVvgTmq/dur38icRg9lj4YHOsofsUEYBbfmr/PrIo275zSDNQt6l5tgaWH//A3dpC5gx33+0TJ7VXavybMD3Q3kOfXVmMz8UicMS9qxgrM0nCMKnlG2pU9GYyP82qgALmVswDJGDNmDJQqqf4oD0J7n9PSjZTikoIz4NSPB7RK4Fd6kDWa0pcxJtFnBgFrluA0GjjZF3dyPMLNl3RZsFrTu3y1CsYDhcjtNCQwFGW29Ki/cv/0IGtzfDBrCwTWg7z0Jy5BpfpEPC6+y9gXFoDaL7Yx9uRyT7UQbFbYra1L+ydKGk=" + }, + { + "length": 256, + "nonce": "e80e6934561a5bca256951d0be90f6f137b4c102b042f59b65c476ff4df1d503", + "payload": "AugOaTRWGlvKJWlR0L6Q9vE3tMECsEL1m2XEdv9N8dUDW5QmdW29j9HmU5hEinKnakkNfBSJc2OAvixd/XyDUffjTfKosru88UvGUUr93DgNCRn+9JE8Tn444CDXU/6tFvJCNlF8AN6kLPNpuROFvInLDFS5yUAdfINB1iIGDlaUfrJogdXI36lLm91VivhYL7qyoap02dELYM7rWHW+ljm3UNkeJR4kr3qyGxRtuEuR+V2t98aMiBCt//auPd236D+npZxtasgQUNi2ZO7TG82rI+MRs2G7C7KfSYrlLob/uI4EfJNL68eQD3h/2a5QUWiMnehy9MA+0jgF/zk04syOZrkZLRUIPfxDO+fGGBVBRKbhlGQd/VdO5Ma6YmJG0REibHm2drFu801or6x/KbPqdo1NoGvfxs6/Zw5cEZEvoX8=" + }, + { + "length": 257, + "nonce": "e3205bdb7ac94d53dd1f4d54825bb913de6f8ae15d5aa85affcadb6c9b8ca227", + "payload": "AuMgW9t6yU1T3R9NVIJbuRPeb4rhXVqoWv/K22ybjKIn7vGnsQVmZCuCDQZpJLRAtcoU0J8Dg7KOvUWUuThdi36aQrUSQFUF6xo3hpL4XDYHfPmfd1RSuotcxZHNwdNbwlUcom3+x6J4Bzr7za4qnEU4XPKgXSqa+0bYzKn9Qgd3NLahhvHxizdXZGXidYW+hjbzJb+pO1jEtau+BH0mFVRXywUY7vZx/jqSTosH8xIvGAHSIb7nEopKHy/Fs3+6vzvThrq/ycJ2EY2vA0BxugJK8n41C04DRug3N8jb6vvEFAY9//U4BukFUOZRxv/SsIntKg2UwBmz7j8RKc1BbXtxtz/NLEvJDtl1IFE+rj5ynrGzhPdz0oppil1/ZI8abhGN22BRm3P1ZIFD8EE/pUrxp3o2jx3Pf3BeIZGXprwJQwYAJHTRl+4hfpthrsiR29Nrcvtiw5jdAyn6orJCw9Js3Q6LFkBWFq8iTwMpUPDL1glGtKdPSzNPM1Th6eNFFFWQ" + }, + { + "length": 300, + "nonce": "e479da7089c604647c0b3e9ec3d6e5d04fb3750c380bdbd53846fd0940f42bdb", + "payload": "AuR52nCJxgRkfAs+nsPW5dBPs3UMOAvb1ThG/QlA9Cvb7h7YKna0eZtLU5zJEhPJMHD9QB9XQoKkNga1L3j23KbWjgIQ6LD8twQ36nLeuYqinuABj8ZMaNhPZkXtsSEJBnjJkSuxTAirS7A9iiP3wrL5YTAqtjQ14kNrfR75/AyX+IDntKIZr0PfBUwjWOCvyZExHKU2SYv69zn0k52J4dK6Q2tsOeWGmlUq3SEt+iXiqab+5DyeYugk48RvpCU/V3RMXLEr3ldX4F/JCM6GeI3ZoLyLsVEdSqgysukqL5Ma17xv/vAYCBEuk6CBr0u0SGb8W16dNSjx77OlgEhR4Oqqiy/XSQ4duYkANJu0aAGiwy+zzwByrhTxW9yyP8TKSAWUCespta7RACCf3I3tZAv/A9hXFZ5PCi414GpEVomBgox8ODI2gIBYIjOWhK7kCG1okIxoqVlMXqI4yBCItC2LR9E6ClYbRGpOhPMHw8VztPKwwsPctW4V365mbi3uN19Z" + }, + { + "length": 1000, + "nonce": "e36590d3c71ea90286c92d96719b2378965d70c6e9ae99b4f9f24d62e25db510", + "payload": "AuNlkNPHHqkChsktlnGbI3iWXXDG6a6ZtPnyTWLiXbUQAkrmNW+lAIxbQTXTaCNWCqnvGyCqcveQBP86SxZNR28Sn+MaVf41S7VGExbgWErUbYzGILQUfzdTPV/8t/eTuEYkje8QyQzf13PZQiwWAwIk9npTx2ZelV6KWqnsVZ7H9FE1vVqI7nEMZPNjPa6pYKMeCvs4M3ITadPXQGUNPT4KxM2rLsYQtTN1CXgjkokRpKpLSCbMtgh0D9tfnN9iUom2jDxeuWgDJprCWhKyGOEExIqlvmvbG5ELkFuwe8WKHQizkfiZkoeSNeCRHorcZlliiFoKTb2g2AfIwL8i2xDZ5CruM9FnXPZdVigspCXpXikF9JciJHyPmWR6wQFKHp47BXK9vL8NHmev6mKwwYNdADY8FfzmeywvMgPqiajvVJ2/euUKuSfaHv6/4Rgt2h053ylKQ6KlXEiAonsoddPFiMLuVk0vDe4Cyuw85YIl4hiW4BO1P6EfKcJEehXic5H/l/jBX016L8PrM8cZtsWuS3/WyamFiOCOTyYSHBIZY7VUWnWi8m+t21gREreUhRejU3u4wtiAjZ0Esse2SgiiugFw4Pbns6uqyhpQX0iq6ow96QOo8+ywZcL7s94DdqehY9rnyQqlsrfT1PHGBBAyvKH1poyNzPGZ9tZ1gSK3OVaOkVNBceJKpXaeBe0KBUozLAziYOjDGMWPSpfcRWQk/qgem51Tx0u4mXiNY9rESJXZ3eDu2HVi8LEuHEKt8rEOpxnEDrq7A4fAcUF439g9C7RsZK+EHmblqAacdmZjCvgVLEDs3YS1a7si7SWK6ZlQMN7u8ybs2zHvOIpURZsv8C7tvB4yI3nY5mEaElYZW+3m0kIAJl1G1WN+9c4o0ywSlUBOKf+pDiZOSaqX28bdSSeepNwXXM+HnKJHDr/4TBrS+WPDs1dPRXanjxPvPTb6nFfK9LvL+ltQwyRz4YdhwAY5TuLTX8SxTiRrFXOBxKDDwLrGEG3/9WtAdxJ5Q9A0mF4qFGxu/eAFpmvNEbEV3FlQN37D9NaoEYrcRwNA1UyWvI8LiaJkSP0qFF0T7LepOf3zizv0G2MCAo5S+fvMmhnOaMoQpcCAE7JtZbyOYXYZvfFZQ2fVFv+qSAaQivcr3mgJJhImNaaeELKkAe5GtPFqBD4MjOiMSX8/Wz1odcEe12tNZmjCBo3vV55VQyF3FBBqlm9bxMyRDJz/PrCIgu24M1FBjZhkkC29KyExDH61NmtY50Ggt+BKMwOm+3n6cZA6y03FgWGp4HYoZ9FZZwKSaMqpAvIbLB5BBtcrwuh6bOWgh/AJL0J1aErAGdy204z4SgiwgxqaRehZrI6MMwkxkY4ZXsFwpHXraeMGmTps5c+OdsyMQOIcnxQSn2yckF6NZIpjNbc2YENuKGT9hOf7QfeS/Wq85vLMHYr511U=" + }, + { + "length": 4096, + "nonce": "e28612b2595f35b756f3a0bafb793bd9ef121f2bc1f1c43c24b4f245bd66e485", + "payload_sha256": "b7ea91415ec17286c160bd289e133f69ec85f8467c797b59c7d1bd34c96600a8" + }, + { + "length": 16385, + "nonce": "b273d218fae37ce1595891ad54d84ce94d2b17142cfc030687a01adac3badec5", + "payload_sha256": "904b3e8b574f5567178e45e4afa32c461bdf6d836d0b4ca2831643f04b2f2092" + }, + { + "length": 65408, + "nonce": "8b0e611b7bccf9a3bdf9d25bfe5423a8cc97fc6518ced6db38a766e4b8070bc4", + "payload_sha256": "e87c16c1004c327079d8977ccd119be3f92b14e765d898811505b55caa356893" + } + ], + "peer_pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "peer_secret": "fba71ed001d0e1906f118958c3dfce27ab9d4967b127aeff8fb8643b81795d57", + "proofs": [ + { + "proof": "217f3ef8a18f2711edc1834433502ec96effc28592f5d6e67d131bc95f18813a96189a20d3c6175797e2a23ae98f690804080fd7e777104eadf3bb1a66f979ba", + "timestamp": 0 + }, + { + "proof": "d07054d22047dde3344576223298c5dcf26088cfb827c8925fcf0c2ee7681c2fe503d9a51d37c98d64cd4975b31c3fdc5335cbe106da24197c282ef0b957b1fe", + "timestamp": 1700000000 + }, + { + "proof": "50bb382a34b7b8d74f9fd41f87ceb3a5ea1162f839518e33ce6ed74b2dc0be96a2690fb10c481d946e6fa2e6fed6b4164bcb1c3c62b76417e60de8c849b0b9f3", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + } + ], + "min_signers": 2 + }, + { + "group_key": "03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4", + "key_packages": [ + "00230f8ab300000000000000000000000000000000000000000000000000000000000000013723ca44629dc1cb1bec88577fb1b89f14cc9ed148ce6ce3433167bf1c86528b038920dc8654b7b8feded853146b4380e28cdf4803f8d4da5b9aba5bf08d5721ea03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000021430b34726e9deb206302fb243795df1545676e60676606f6a263ce890fd54f103b45eb1b242cb0e238d7c13fce318bebc12b1662e83c15048b06d38d8fb50a35a03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000003f13d9c49eb35fb98f073d70d074103424e8f2be17366f43750ed709ed5aa989802f3077e869cc5be3a3374fc7bb4b076700b2b8d973218145be36a8075dbf314db03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402" + ], + "members": [ + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":1,\"verifying_share\":\"038920dc8654b7b8feded853146b4380e28cdf4803f8d4da5b9aba5bf08d5721ea\",\"proof_signature\":\"eebc839718bea134b55600384356b800aeec840085febac67e008ed7b4ffc65d2815e3de77f7b0cb0ceacd2b12aeba8dd3296339460273cb541dc635b46caf65\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791465428, + "id": "fb212a4eff80ff8c139b29fba36a7c8b77113aa889de62fcc17688a54deb1081", + "kind": 24242, + "pubkey": "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a", + "sig": "34def039604d77687cc497f0b92739caca023eca84b1c3f20ebe6448d5dcbae3be2273e3cf0cfaeb9accfbeccfffb8b3e0b050f90655f119559cbb7bb33c7189", + "tags": [ + [ + "g", + "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + ], + [ + "t", + "announce" + ], + [ + "p", + "19fefda587c2e26acfe3b3fb450219daad6ea0393d2279340622cf4e46525e14" + ], + [ + "p", + "d0a34d6afde51f2e9377db8cf7c1ede771a281942bacbcad6ef51a759cddd361" + ] + ] + }, + "events": [ + { + "event": { + "content": "ArtYJv2Fn2eNgzGBaeV/CNgaFT//tTyxI7LIlm8armpSf/GWuRNhRalsoLInL7b7KSmgmH9Ewgz/1xn+lvuYutGyu5OVZyYFTUZy2+7iOV6n/SZdHer9VgdMqJjOsYa1HHYXbNFF1XKNQU4fdpAZSz3AADmZiZmcqFskOsMtshXkm210JsZCdIs3ndfiPI65Se0SzRdvYr8eRV+qzQCo+YbHWXAWx6NxGi1/8H2Ap/F8sfaMyJ5V2tNRor0u2P1Q/wIN", + "created_at": 1791465429, + "id": "02d2132138013ec10afeccb57f6304bf49059f8c1b9500455229e3eb55a16074", + "kind": 24242, + "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "sig": "e7042d69baf30a491b9814e93de3b7ae378d8c4d2f13319fe1c8707b18d1553250dce5cf5c1c981c8f065559dbcd4cd83c8142c8a72ad73d850f07c74d8c3425", + "tags": [ + [ + "p", + "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + }, + { + "event": { + "content": "Avz184E8xzKOypiYTv3fCVFDuyfJwbje+jg12GXVzoR/dJ5Nq7vtbeVjxq3nn4W2F0Q/1CraMhK7AfgjmRkEPJNu/BSHwG3TmC59dzGXM486hQjkZC05u00PHxi+qqNPJZRlU5GhJ4kcHOl3FJe8iRJO7dN04JZql5Ie21WPKpCftfT4+U/vYF0IYXxckamnhe+RB9/spir1G2pcCsabqzBdU4JYydm5W0arEn9whkReaTE7facgJb8UtoyAv6Mjz8a/", + "created_at": 1791465430, + "id": "0f9fa941a63b2ad47b09bf715aee358b3bdf7edc579fe58e0e6d14f37a470a84", + "kind": 24242, + "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "sig": "6ced06286d5654a96fbfdf8fee45c78c08ee4ff6f4a9ad9def246afa98a30be0a94e0f211dfea48fdedf733911cffa429d310332fc97ffd953f6b9ed832a437d", + "tags": [ + [ + "p", + "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"ac7ad4973b290ee2440829576115b0eafe2a930ee4af41657adfc2f76c732c20\",\"timestamp\":1791465432}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "695138b4a46ab95d11e815986e2833fed7f27679478823986822ab7c495a9e14", + "payload": "AmlROLSkarldEegVmG4oM/7X8nZ5R4gjmGgiq3xJWp4UmXd/G/jm3UcQko8dzTZLyN3qQp2RLdJvtGgMHLgBzzHXgNY46zhoVvd25k5JwdVnvNabDVdewZAI5vAwQ9wUh1hW" + }, + { + "length": 16, + "nonce": "2cacaaf9c2617c55b497391f37f7ee8f62f271732cf83e68a4e99ac4a09969ac", + "payload": "AiysqvnCYXxVtJc5Hzf37o9i8nFzLPg+aKTpmsSgmWmsoLUB/Ye4oLsaRDAm2NcJc0E2nyD5KwAlNXFF4pes9030ggZtq3v9gZihPHIw4oJcdOEPv8BjyTiGn5HvxDbNq29v" + }, + { + "length": 31, + "nonce": "c901644166d87da5f50f5a7aa011c023ede31bb743e6dfef44c9656c58dbe664", + "payload": "AskBZEFm2H2l9Q9aeqARwCPt4xu3Q+bf70TJZWxY2+Zk28fNM18qkBSbM7C/fMab6jL1WV1Dd1dDGcpsFMsGgu4V8mA1omHRi32I0DvyEsz5ZQ8WX9d+ARd6DQceAVaK/PEQ" + }, + { + "length": 32, + "nonce": "017832977b614514ecedb8308146d386ced3a07d2859d9940753b591bbbd210a", + "payload": "AgF4Mpd7YUUU7O24MIFG04bO06B9KFnZlAdTtZG7vSEKDzjF1BzkHHiIZub5GYzE8RFu9z1b5Dw/ya3zmAV158/meLE3ID18TGySJpOvWpvQ0Eab6rSHVYK6m6YdGWlVFA4Y" + }, + { + "length": 33, + "nonce": "3623a8c60de9ef7de5ba0e517b662c38283614e71a72de9feab54af9b93266e5", + "payload": "AjYjqMYN6e995boOUXtmLDgoNhTnGnLen+q1Svm5MmblP4TkoALT8pJRr/HpAPGyF4CjX+ZfPCUTaRFu+JObuAvvnIoBOH4DUKbhOmQ3g/PZVSQZNGfXdFQiCv4Ail2ukJYCb74StR+eqIY2BPgZH830c3dSqC/qxjCu4hFuXb20JEE=" + }, + { + "length": 64, + "nonce": "aac82121ffabc5434ee427a37eb172ce4b97772a3e8d95b9414cad50611571d0", + "payload": "AqrIISH/q8VDTuQno36xcs5Ll3cqPo2VuUFMrVBhFXHQKL5nk58ruzXihgIQKArv1cpJCTJ4pZuOhVmffA9ywkIic7HF0+AFxfGEHuSvAF+4CfnoF5yySIq3p0vZckhkAh6HaoMT1giRMJ7eVibt72J+13zDgtGlb++ixyJM8g/Nxe4=" + }, + { + "length": 65, + "nonce": "0abae9241cbcb80f350ae383202b8c16e8428065b27d0c6e4db2b5290cb3e6b3", + "payload": "Agq66SQcvLgPNQrjgyArjBboQoBlsn0Mbk2ytSkMs+azi52hW3oyz+qYsHC8lwBa5St9/dFOQKuL0Asia6h4apUwjsJbnb2AKstV/2AwKHO4pEKt9h73fxSIL+QAgBUpE0DWYyxAW5xf2GHkGKkBAFywbDiLQI3EXZukSHdMBA6Js5O+a38mHMh1p3ntAfOQRxa4UohRJrXoiID2jlsneNfeHw==" + }, + { + "length": 255, + "nonce": "b1e50d189a764c5c74ba493fab3c745ac8ac0d340a7e6aa024bb039a77cd005a", + "payload": "ArHlDRiadkxcdLpJP6s8dFrIrA00Cn5qoCS7A5p3zQBa9unUF/p+tbByheXFm6J0DbsPcADIWuj1uNktR+T/A5ABVQ0CO1AqaY7Ok9n/lwSjcIYUsifzkIz3JF/VLIYXV4D3d2f//GuTulGaxk8p/l4yPujcwxhEgKJ8a8mS27MJZ8OCe4JuFo/+8DdIXbw+hG99/7OMUUm2AO7Kh/wzaa4zAM859QgwMcyWR12igTGPhIXwKsMMrNVRiEpQbkGPtCVslmkxG8D1RXg/a/BSjwhEv7slSHgGKi4w7TX7JRN196hG1R6ag4uKPVFZV/WUfYA+tKkqbUVczvLT9n9q/gLnMoX/zuyBrtNVdzHWIDsXNZZHbTl83fqlT3Xkd3XeHc3X23v9cza1iNCJjhnmVwhSGoAyhWNmFL7/XpDJa1spshA=" + }, + { + "length": 256, + "nonce": "b39a22e1885eedd78baf6e976e33bcccdcfda99b100b93cb3aa292a239e30fc3", + "payload": "ArOaIuGIXu3Xi69ul24zvMzc/ambEAuTyzqikqI54w/DIt4UqUyAABTVCsZi5TO1GtxrVaT5TD5gAr8NXlpm/xM0hUtPer7dG5v/Wx7Igzf1tqgTUMfF6PkARqiC8/gKmxlzBhOlae1iqCtwOeJPh88BTIzvLTctZq36AeFZcUrZH4QGOc/GC7SkWjScDeX7lBvtL8T636IMLozZRdXn4liJaKx2K/Bs7gEYm2lbvlq34fTskHj7JzQznmt+jfZTzK2hPZF/LKD9jovXboKBhxJUcX7uiUk7DIsiR1U9PF2JDZNPc513DkIAW7obblYHfR5HjhBmoHij+pDG4bglDJhcmaWKU+NItNUcy/kku0SbmMhe+GfyJkQJE8Pri+u+YHkkEAQo7bHvsYsUpFGFa/MpFgo68c7eesxPjxsJ9Fl/SLg=" + }, + { + "length": 257, + "nonce": "b3c08b3535f61f830360708f69968daf7af5c411b778c04939a28e56fbb1f0f4", + "payload": "ArPAizU19h+DA2Bwj2mWja969cQRt3jASTmijlb7sfD0a2TnbgnBqb2itCyJyGKIvuWXS8Jf7ue3pZIxKV2YtMeZGIEVfjwPED3+mDGIozfauqCHc3uKJ/rjaCQo0K3LIZ2Bmucprpi2PaziyvM6I4oHHtTIg8c7K1sX6hhF+E9SBigmwpA1u3i4+5kusaY8ZTPwu4ybqCStOajulkld+cxM0FYNDfKbMjxdOc5HY9eV7YQ+jgb73mZzl/hzKbtmNZq4QVWl9MsTzwS7WhpyqBNN7qkMn9Is9mxZmJOk4U+OhWYsGyWXTfCDwTx0t/CLHj0VHqHCxV0OblwUTG/EjOaEODhen3ydM6QbWLRkVz9WmWFfNQcIn4hFusg0zm7RZZPoxh/Q5rdHJ/cfxU+///H8SG2VY0f7FbYkYxau0HeJGY6kimvxU4v/Nkf/c+lWos2xYidyfmBzkzb5Jt9soTy3XovJEWs2RBmX7XlWMXi9aHs7R0f29XoSM07UQuwNDQ/y" + }, + { + "length": 300, + "nonce": "7da2b5d0ea268ee0457993b08f40c909a8bca6dbe15601d2c7aba29fdb4a45ac", + "payload": "An2itdDqJo7gRXmTsI9AyQmovKbb4VYB0serop/bSkWspeHheDPwvCjhJ1L7RQpBCzcmyvaKQf4pCoSrszvkuEKkFe2XcHSj0+wdPlUAPv8rVa2GqORcsZFkvOImjbnvzVHBvKy3mBJ+6EBhtdaHtjPUfpI3FdhQVv0uFYE6+LzmRbLE90rv50IUgXucnLoW84wCzILIYsRSxkaq7B9YS8p//bTqSregFZXl7WI4RcD4+lgaQCK1jA/RYo2eAfE0duaK43UtI5cqp5T6Rr2hxA/PhGqD1kBqAUVOQqd+qvJJ8o3KF85suQnA9KD4dXsFxmM2J3wA0PUWlPD20ALmdCfPy4gTT/ox4oAfcXv2EmXL7wZOe1Uoun9Tb3Mk+WLjn+sCTq3yqgK2rxhAFAe9M96DwPzIOWN7Aqw+3TfILqphi4BB7R/6hje7RkRddPO+h0aqTI1nuWA0TvaNJe9b6OXT/7A2BPh44eFSfcnixtJNTGiApb6qqy+69jus903Yexwu" + }, + { + "length": 1000, + "nonce": "8c11c3f49eabda816523f24b6e9fef700a4ab0bc3fcbcec3905cf485134cd6ab", + "payload": "AowRw/Seq9qBZSPyS26f73AKSrC8P8vOw5Bc9IUTTNardwjcaXNpOBF/vSYYvyQHX78A8PoySP5jyyqe0GQdw6MsZKZVsN7oYOoRgXAIWCBnLSWv2w4S0OYTFqequzKxm2B5XujA00sHmfqtl3ih3G58BjIcKbsNiVPBoF2PYetLXS1nkeVU/mueYerJOUuxC1h/4IzSryqPy7BQzTLekAy8A/RSbQOH9HKC9EXIC6DVs5IYt1nNs30LrTXzqMEZ9ur9y/UwxAnFfZZfaOs/UVwSNAz1gpIEj9R5gR2AL6ut4LjTlI1SbfIlTpF52Bhaa9AaXqEbyecrern5HdYpk523v2GYZFtkv1baYAqCEJr5GgQV9gNeZ9vhlDT9QUOR63T0IpLpu+r0jxZtwWgl8K/9XRrvAKDZW1MLEuWPyQQfc8Cv4ZOwtI8BW2ZGLbyIoDKXaN/uKkZX6XLRdafUSxRUkPWyekgFqf/VdK27y5ivIw82mBWaN5N6iCR1/vY7JXVZc8VjlnNcKI/DKGQZNCqrrYoI6ThJX/g7ur+cRrBweR3xna4k2YtkUUpITSGhguSVhTJB3Njx4QKozSu8KT/89JINTB9+Ac7vGPNbOVb3JV4/W73/XfQTdD97V9sSW8NGj/a0h7rkEzx4XLH7axh38MP5foC++zOAQ1QoBoNOhpv3DnwmOiShLc7l+6d4Yn4iO01mMdJi2D0NNrlpMAJCfV0VC+nukRv92+PaIUBcbxBrJxwmjKXmBt5xJWtJ99143yMkPf1TmgFVNqmr8PhycMuUVBwNWUZMiJp0pdu2JgEDJvUBrGBE+3Rr38GlR3iv+rscEy6sgcpbiYLZUw0bhFW3Ryb+kuueG83Xec83rqjYyUYcpXYrJdYEMdcNMh0CYNVocVOasKHbmEP4/WsY15bc8rsUxEgEjTb8DXk3TrgfXB5OrB90YUJuzVh5qYJxlJsVp6XvJK1ebGcAgFdQAij3HljRkuLiJ1YA5w8rmWQqTQY8jtHy+4d3uCl+8sv0FmJeI8LiCL5nM5A9DNE3CrFTEUif/+jB9fAzTwQNu1m+0fxzlBeYAg88VR8IDLvmrMbFtDP8pCZhftebvi82oerqVIj9CR0aNrM8aDIKpegSt2EiIs0wRoP74rxqGP8EWDVa/KRb65YlKpFVxatun2RTxrOCKJMgYqQ/7hrAhytMQYc5EHrCV32iEVZMmAvUs9PgjHA5QXcA2TFDWLYMEVvC/tCrecO3mbRQCOPQd+dOq8XPHopBLAEdtOhvD7UcBwpdMsQbGwG3H40DD6QI4hwkextJG5do/k5p49xxs0ZwK6HDEL7d5cmD12P6DGdqsyDaYUOu72z9HiZEaJ5clZL9uYGUIwjkhcpuc5ByN8BcW7aUgHlYZpPLsZVIs+xKp0wsMiByoB/9yeJ5LGfyOq/n1zSciMzQKsAdYMAKBAI=" + }, + { + "length": 4096, + "nonce": "e78e69c1782b1e9dcf758064e2376ea2f73f8327eed943c4a0696903bc33dfff", + "payload_sha256": "bb234845e942e8394dcf29ab790d33cdd88d484daa230972144d37fabc672480" + }, + { + "length": 16385, + "nonce": "a0643ce5ded80d33414e78a3aae6e3d48685841af294fb8a8bf2f69fe23e2156", + "payload_sha256": "6299bf335b9505c8cc0d137eedc92fd5fee4c1b4258feb25df032d5fd9159e1e" + }, + { + "length": 65408, + "nonce": "4bd481c509b7cb6dca03927ad5937f890dea5d0be4fff0db37617e9801ee58bc", + "payload_sha256": "3efe5f6095014b3469c264998eb8daffad7e35542d671c5b8fa74ac352269bc6" + } + ], + "peer_pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "peer_secret": "ca569568f08eb04e77a3977e2383669b0d256fa180647f42b0cf94478678df77", + "proofs": [ + { + "proof": "67f487862c35499b4e1c75671f1e05a578d75d520a46a06e761a44091076078bc9304e4c4191762cf770cb0dfa4a755714fc5180b9309a4b4b1b0d0b39da0bed", + "timestamp": 0 + }, + { + "proof": "81ea3b53366c57c2ef5f21356169472a61be81d694f8b9c3e75d61cf7c916116320e93a5b4f4385f94c778ed108fddccbbd37743f609b464e0a05251d47eaa1a", + "timestamp": 1700000000 + }, + { + "proof": "e8867104aa0724031cb6c2f5167131bf40fdf594aedace2ef9697db1fc4627618ad9340bc391328324c44773c1dba0294d4481262c1e833ca279d15cb8573830", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":2,\"verifying_share\":\"03b45eb1b242cb0e238d7c13fce318bebc12b1662e83c15048b06d38d8fb50a35a\",\"proof_signature\":\"f8bb71abac1862e8823c450bc72e75e62865f9f4ffdc75cb585b1f4a48b21123f5d6ac00111859e7e78e3e325798360d956476f460459891a7518b0617389f64\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791465432, + "id": "42f3bfa7d1393f293619d65b5e0d003267254e5886f0782b0d5ad8d058ce55d6", + "kind": 24242, + "pubkey": "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d", + "sig": "29b56b944ab0741e05caef13131a3b0803d88735982665376b3be9f49fb0840cc76c8e23cb52f8e2762b29d50a07502540e4070f6291cb09d3256b7417e3053e", + "tags": [ + [ + "g", + "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + ], + [ + "t", + "announce" + ], + [ + "p", + "e76c7a6faa1386b239979bb5f61355ad5339b782170a5bd296284809eed623b0" + ], + [ + "p", + "d0a34d6afde51f2e9377db8cf7c1ede771a281942bacbcad6ef51a759cddd361" + ] + ] + }, + "events": [ + { + "event": { + "content": "Ai/lO21sUhh1E6fh+kYN5Fw+nEgx1JqX/c4KSL3BjJRVfS8qnfNVJM0fdEW1IeyevKoU2/GPmPQwvTfbqquwU3yiSYGGUUfISR93CkQs6iBmbK8W1R9Y89r9pxAek7TB102/NOLWD7v9cHTYRVMkLNZb443gmR4sObmVOFoRV4VPNKZ4wja5gyNjysdasYxLlV9QsU47kLnxJqWOXxAIoBAY6cRFzRqtSRBAnReWb/Lz9bJhO1f6Ttlrbjbsw1lc7WZ/", + "created_at": 1791465428, + "id": "5981a946a935348bc039c125f3923d4178b6c713844743d683c85f0db278ceb6", + "kind": 24242, + "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "sig": "aea01bc5327fb1a71b4e82e9d70126c06931025c1780a9fc22e9aa31fc825617df04d15e83a6fdc6625f43b62a2e1802d32e06e29c9b85f8130785d778d1b7dd", + "tags": [ + [ + "p", + "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + }, + { + "event": { + "content": "AmT9f0WKxljGZObvlvvprNniBwUhNBGz0ltxXR11E9SGq8sfSwRzmziBgKPJfrnYY2Nsymg9JkPi2vpsSFEEJVxZXJb3rNSIusN7/xGTxeuM1wyrVktBeQRi38pJh2rCjpZE4Et/0iZVrr5zAcWsbeqiz8FoDbpOgAZh9mJFrvE93iBSm9v0pIhYRHnADE0x0NmP4dqXPmIaGgj1UqWG+vKPnfsONHxNliUHQqUYs0uW1xp7lxqMpITrHBva9czALthd", + "created_at": 1791465428, + "id": "6868e6a98d9c8fc7e03cda50b7440adab35d691baf92084fd09e6aba493e7bf5", + "kind": 24242, + "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "sig": "a202106842d2d4707cb0a7dcecc555a01f92f001599ba59d36dd9c121109452fbc73393fbdf0b8a4ac6829eae4007ff6a617cbec8add6627e4cc54de87be9dac", + "tags": [ + [ + "p", + "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"14f5b9f3811d3a7b58b5da9c704c23c12dd81e1aafcc34fc9c2a757961a6973a\",\"timestamp\":1791465432}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "023adec4b3185e853d29bd6d700791a32ffe1e34586a96e5c7b6552e9e2f507f", + "payload": "AgI63sSzGF6FPSm9bXAHkaMv/h40WGqW5ce2VS6eL1B/9Ax8xap11Qg72GABgG4C8K0upKj3u6DPKOC0Gmt5R9zVYeRMXo/h/wdIhu3ip2tXCWNCgX8Fyq2ERDuycHDydy6u" + }, + { + "length": 16, + "nonce": "d923bc84a276b3952a585baa2bf3cbc3a6ac5064b05a3f3b7f54ec7b89a6f2a8", + "payload": "AtkjvISidrOVKlhbqivzy8OmrFBksFo/O39U7HuJpvKo8ZBSGpJl+K1KZpPpYCAHMV0lGBjV7JL5lMjqtfQfR2tqGMjWB1Ki5N2jgOUaiqrkThcJHA+KH0jiHo2MhL8v4FX2" + }, + { + "length": 31, + "nonce": "456922bf1d29520ba0b9763da22be2e4af1c95d0f77c6589eb1ecbc61ce06392", + "payload": "AkVpIr8dKVILoLl2PaIr4uSvHJXQ93xliesey8Yc4GOS4SQiTc3IIuCiesuk3txhN/Z0N2q0vnx/Bti1W9t2X28lyGNGiSw2a3cU1HJxXwyom3jfw7AlIs0WImPIHlMBu3iE" + }, + { + "length": 32, + "nonce": "a4646a505abb3f5b267decd7e8d18a7dbf05bbd06f9a02c5b43d65a53cb63fd7", + "payload": "AqRkalBauz9bJn3s1+jRin2/BbvQb5oCxbQ9ZaU8tj/Xbx8VZyO3ZIIQA+TKq6B/H/6dlSP2SgBTpL1hjuYA+C2LhEXNEwoh8B6APkgyEjUq8EaK9fsblg+ufFkSg6+mhEpV" + }, + { + "length": 33, + "nonce": "4d975bf472a17c4b1e1598e0ff76d76f54f2a7ee8a4b3063c856f42a4326a1a7", + "payload": "Ak2XW/RyoXxLHhWY4P92129U8qfuikswY8hW9CpDJqGnkKUPyqplqTeq8zc+BF7k1HsL/M9q42405DpBdLtt4EM1W30/FRFKeK2GRsKAOirZm0i4AgojeUbgOTU/It0QFQ9dXzDvItaq0uN3CzQEtP4drrCl7+C0xJ1deuqpnseI4kY=" + }, + { + "length": 64, + "nonce": "1a0971dfcfec48a57b06b2326af0dad4d6f035cdaed762d83a8532fa70ba33e8", + "payload": "AhoJcd/P7EilewayMmrw2tTW8DXNrtdi2DqFMvpwujPoOHZeFdG1ZEcQala9iF9T2T6WN2eNjGl/88d64XlFcFUNiMmMM9pUD9bbW5HtrA+5oknqocbPBer1iTHkan8n3+jvrdgjQPEQnjLR56RcdQFXTZ3AVxaiwp8aWsjc60yvwSA=" + }, + { + "length": 65, + "nonce": "bbefce463d9280e0ce16b3521d4619103483f632798f41fd16ae0fcc3d218752", + "payload": "ArvvzkY9koDgzhazUh1GGRA0g/YyeY9B/RauD8w9IYdSTqGtBY/jGsHhTLKcvccm+3nTyNGshGUqqq+PtYJc/IKKT+91RiXNfOgJUCaIjlmChdyJdMAFuYFi0RIc0lkejV65orWtaBs6OSc/S7wdSX3Ib+H+0zjvO8YD+E1FyOt+jXuG8c3t5wFHBZr8QfAsDWZJS26NSNhkXmzY9datbzb0rg==" + }, + { + "length": 255, + "nonce": "1097689c08b5fb673c55277aa3e9cfe47106eaf9b20e42d0ed28814a4b69952f", + "payload": "AhCXaJwItftnPFUneqPpz+RxBur5sg5C0O0ogUpLaZUv5yc1mDq9KkKSKxXsLPrl6CF/3YqtrGngjfSTIn79mRcx+vFEpM4B4DoYmpAVVLB+y18zSRkxjWc7hYDjklSJIw+D/8sc0Aa9WYwmnMZQJi3FsP1ZB5sC3HZetFTUn9pasvKDtqYWEGrsWwjVdONj1uqzBFD9HofulwTVfERoPvPn/hnh7GS8x/7FS+DaiUeh6Q1VEjArdneR5zp371KDQEe+faNIx0YoXhaM5S83yW+Fig+Nix+cnGEcnAep7eeUQeeRp19+7BQNpAB2PMbuJ2mdMUMMnqJkepuv/iydh4M+Ko1t3UOzPDddAMhuSxhIvbAGc04ENEEfuXmWwFsoisKRd7STIkhsEMuLHaVxmBHlwOCghCaMDpVtoel91Bb0XOg=" + }, + { + "length": 256, + "nonce": "e155e03bc1ee3afd0b4979a151da38090e78c3d68b318f67d617a8032f454ec9", + "payload": "AuFV4DvB7jr9C0l5oVHaOAkOeMPWizGPZ9YXqAMvRU7Jo7WPj6Atb7ZTZCpdCi/bybbyYKAUdHSYzQeKJ7Jbcfmr6vJ26qpG1UE2hzWHT0T2dkMWCpkkfe8pMd7oXHnVF+vbhdctqSzz+tYDP5I1ObQDeRZM4SxU58wTYiGQoppvbUK8n3klKeYBLqlMroN84ZV8EQK23Bp/uGQH4Tnu4PWWsgkTYGXmY6v28Uiz3Y1VChlWVqmHJVMpu5opVhVxHuMULlqQd/MIAvLpJRAWqRa20blymLTI8OYMbJHxRONl3gHNm6tsoMUFXlQFpuGLCkVbA+Bb45FEqd46uStZUUp+3ykBYIAiMMPHauO1hGD9KklZy3nzgdFgA/YKeOvcnCaoQFD9uAo5TK79wXz7f0z9WyvwKe87lpMyXzpJ8IQJPes=" + }, + { + "length": 257, + "nonce": "65e20c2b49f2b48815343735e35bf7c802b98bce8469cdc1f962ad3494a62dfa", + "payload": "AmXiDCtJ8rSIFTQ3NeNb98gCuYvOhGnNwflirTSUpi36T28XXS52Z3t0jpVrOqUyTRrBPwExYVr4qyXh5Em6kzGbBA8S8MZ0z937Ob+c1pmX6kKnkKKd22bFlFNwpe4FXrRKSlQ6Fg/0NBoqNZRIdVGeGKPLtPT5eA0ncsdWnDKlnq9VL++aKAolNix5hB6vpbELB/4ml0l7FDXRClouulgmcLQgya6hbi6SaEkBwW/ddTGwz8zlZx6RB3wOpxnJyJP8qO8QtThmQMfgCuBiCKsxGVoLnaSN/tUuFlhH0XEubeZdi8CPn/L5uHxlwfrXiOIPgDXIoQKlfgSQGg93MDvn9X769q+RP4VmtLQuLVSJPlpOM+1MjEU6lqBzk/uLPQ6igT7gKElCgmZY60LwM9fHA5DFOL8jbHSxvJ/eKEiwr0Dgd9AL+G7iwu7vrc1l+is8Zlp9+8LmhtzO4ovf4A+V2c3LAG9XzVj0rlR4FxOHCfI7XcCTOA7Eg9fskgVArn5k" + }, + { + "length": 300, + "nonce": "50606a1aa738b6e15b93e2e97d55165471996867bb523ed4161e91f8e9a28594", + "payload": "AlBgahqnOLbhW5Pi6X1VFlRxmWhnu1I+1BYekfjpooWUoitTF+Hs9ygUFAvK582k16OD4lxnc4IFtmIBLhN9cqjKtK+hgA/rnYqPiD0thXghD8tXjozmxnvYIcSFbLJjVvKAN2KOAb7+i+QjI6AZJy9Q2ifFuv0XopknRYBJT2UHATaaylvdnoqCMcf7pJFMUTuzlJlfzXp+CSqgaVtqDk8IZte/8z3HF+fpiljQDFELUmS3kWbGFObsZ1DueTDTHqep+6OCwk7X36xQGY5nU892AojBtZGxl6TAC4jo1dFGk6SwXfkMc3U+3WpvKZooYEgNG00lKfA9ZztBM5daXjlXntgAZZz8p5ZLLjlmxECBsFQLQhju0+41yJ7UjndRQ71DRGSgzO+fGcVpJyJeL8YWGsSrMjfPWbQai0Od+r/Qdyr/eNYYDqdnKpArzfH4CNAlfV2uWDXO3IicQViRu3+h9/TF85zTOXqrKrOLayGLOjrIAEq12ivvRJCoFbk2FCWt" + }, + { + "length": 1000, + "nonce": "aeed88df44b7d7a6bb8f6ceb7265e04a9b8f82c5fa524e5ec2c293a515e66126", + "payload": "Aq7tiN9Et9emu49s63Jl4Eqbj4LF+lJOXsLCk6UV5mEmrgBbBcbs2SJPArqgLKiY16E7bf7ygwporRDT/084xFCfA2l4LffOxD6JKn1gdtKIA3XzAja0P8H4FH36sgG8NJEUsOVXw6hM8GZ1ZWhrHJrl7UTu5fUPuglqGYyTSVHhKwtfQ7h+oxwCOmhBciWMKi1A9bZ21yjIcxsYNsuFnjw+mzBSJecxHjsv7IhRaLZOzo+9A6zNmqJuYftn6rDlSsavLWl+gOsAHTtWRj6YkOZErW21llzsbDS18DGon8leXisZqCtYXbOhHxipxLuB45ErP+OjXdmfZIEaIUQgOeXJesM7j5tEFeTOM3AT7+IIMExUprbc5rHeIWcC7CFy+tYsot1M07Ey8Q1zgDO5e6oyMNyPLJwagMc7TAc04qsCftL9cbzpUNNjdLMwZvW7DI/LoGIjHg+3HSRMDyezIS/3tnQ7hJjwhYi4N7h0+yYasvkJgpY8RpCyEd2kQOPFAE8CeyfcdglK8a/A8eQcWec2kvX7oxmF0v8DLw6/3tP7suzmb37HCCceytmeHphOIM7oS917+xZWNVo5eL/oRj02wtsLiin6BZzAY13U+v6dnFqFSOvNF3zakex3nExTxZgoO4UCzMOnY/rnybhBQ4i13fXcTO6aQTNf1RdDvk9ENF5ZieLnrE0el2w9F7KFRWQFAyFFoi1waQ5KX/Je1Ul1Woa+mJDp6OsNFmwOZDAK7TWPfSd0bXXTtw2eGtUhcEKSu17jmWF+y4VjU/TJOlzjzDKHWUmBw8CwAZU4FItNlyyYe4Dx2g3a8SAVN5guhg4U+/fH7rY9o8CO9ZRmM3cZE85dXVhoulSyxV3WEIXbPPCnj9Jxd4tYsYAVEWDJtClmOsyE1wO6S8N0p8hM8xul5g+ZQvxnFau1OrLp4akq/cJMEvAhXFFoJTnC1wAezU+jD3/9LcfeqNgT4jc7tZ1h9wm1piH3blGth24933ZYd/Avexc9Z1vg2t1vT2C+xb00sQAxNrZHBG8a/JoCWb8Q86240FkJ3cODjh+x0OxxxngDJdVe6+QXIARbYypl8xSO5uY0OH35SHWMc/wX0b1p5ujeK1Dknp2gJYGOlxUWQiMEbRokRQdOq0DHLr7CkP9AIWJVznZP1I2uz5QHS6H9EK/aG1aDON9/8rdiDUvvzwcajhBZOPELsCgG+YtBCw5WA6/AvIXnmCf9/OllViDKTpr6iAg8tnlL7fXb+4oc491MlI9Bu1/YuwGBZ8Av6VNjXp1kqNJmQ1+nvk6Src9RD/Olt7zrWaI6FkPbeU08WWnQk7yHp0/QXGCV1Aoyk5cO3ZEwEgGdqw5PTV7SuoRWaS6DXkqfFjxMobEjHuFBWGnPEI149S//oEtBhAhG2SlNEgOzgQPUkUlf3zkSsSGJ0SJps3O+widslWSS3qltXPM=" + }, + { + "length": 4096, + "nonce": "848b0b4d876eb289d0888fd9ed35da95cdfd34e2fd3de6e72642df24d88c5aa5", + "payload_sha256": "2c2d94e20d78e0731a34407ff0851ea4c3b7b7c60eafc8efc7522fc4c13ce06e" + }, + { + "length": 16385, + "nonce": "7db36db2f88426e9adc5802956bf00113b27e9c8324ced1257ac8ce1dabe323f", + "payload_sha256": "ff10af665857b809b17f651c14f1a2000792dc1967f5c86029e54a64c3a85630" + }, + { + "length": 65408, + "nonce": "73a093dcc5202414c2a42edf10400e6508869b5fc44a607984c9b27af6d469ba", + "payload_sha256": "ee065e785925a716ee5a5a2423938280f4e772c899af04fd8c94b172651198c9" + } + ], + "peer_pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "peer_secret": "f5802d7def95d950fdfda4bb3e4c119769b87389eeaeff80368f787124edd057", + "proofs": [ + { + "proof": "707762b53e6a3c2ced205b1cea51a26c845608c4e2a6e42240f17178e7b661d6c2e47e5e5650dca54d5cfaa21830fd9730a041a776589413aec4cc3ba730a1ff", + "timestamp": 0 + }, + { + "proof": "c015df0ea8d3777f90763b343e89e019444a541350412c601dc677810f064ef8b56fe73d7845ecbe30405971677bc59112e72f59f144238bc9d641d94b83f3c5", + "timestamp": 1700000000 + }, + { + "proof": "962d6977b0d15af1d4375ce123b91734fec1b2c478122673e4159ad3ed53bb11deea24676068f3fd17c74fcf3f141f9b4d2fd2db52c22fab50c4cd94a1cf9f0f", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":3,\"verifying_share\":\"02f3077e869cc5be3a3374fc7bb4b076700b2b8d973218145be36a8075dbf314db\",\"proof_signature\":\"90b1db00f7605a7333d619badf0b41280f72d25effb70ddc1249ed2dd3af321e0f3cccd2cb3f8dd9ec1e5a1279b48653057f6c62260ca2954e3d11949ba2ff95\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791465432, + "id": "34571a6916176e75ae6c3a1c38c01dd2c315713d7e8f7e1ac0ba8284fb086883", + "kind": 24242, + "pubkey": "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2", + "sig": "df9da4aa0d9649b560c540744afd8d013934723973fad58837ae5fc27b8ceef3d76eba08d329d69904c198a17184f693e309c114dcd1f714c51ea7fadbf41335", + "tags": [ + [ + "g", + "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + ], + [ + "t", + "announce" + ], + [ + "p", + "e76c7a6faa1386b239979bb5f61355ad5339b782170a5bd296284809eed623b0" + ], + [ + "p", + "19fefda587c2e26acfe3b3fb450219daad6ea0393d2279340622cf4e46525e14" + ] + ] + }, + "events": [ + { + "event": { + "content": "AtnLDH6lAmeQ/voDwbFkNF3qyZ9dbTFD3pXomkqKg3izEg0oPuYpeG8MsgBuTugYIL1kyfYkUvoP2jkFjjGzLRc5GDlwWM4ElZwUT4AmywSTM/gGtSnlLkbh0B0SnGoEA0pXBH2sYk/VGIzt9J7PJbsEFmMFsv6oQiEXFC6gTHtJP0g4oiIX3ThEoF0FrsENprArNRlqYufi+zTN6Oz2DT43Y7+PbN2EOOhSir3618/B8zaRPw6IFmMekMSFUBMXIor6", + "created_at": 1791465429, + "id": "cd2c35ab61602ff175b13ea588c09077abda06041fcc87be0167f3201e125e10", + "kind": 24242, + "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "sig": "8cf7a20e90180896bebc81195ab22b857e92b3a9af30bf4a70850e9c26ae35de8f57d68a3b64637b7dd93dd6ed68500cb93dd03f4478435ebceb0b1c3640d9c9", + "tags": [ + [ + "p", + "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + }, + { + "event": { + "content": "Au7DaR/pB6N568/wNCOSv6Z1deraA3i7gSdcvexrH9Xz6bkAgC4Ef/JpgVJBI5yRSjpOmImxV6EoS0XcW5D/TviU1feu4RXTkUfSdJ4puWhRJfJCBtqgLNo6Floqhpy6EMTR6tIkrFqdAT7Bf+bXL8r4k4yr0owyUsX7VuzBr3MvW7tGKOz9dLZZgl+wdwzAgzzLdL+FaohpQJP98nSrmG3Eirgq/+IW5ZgYM5mfEi/9yc0scyyzl3B8ataUf4dtjjKe", + "created_at": 1791465431, + "id": "e50a333b6801cd5f892b58c55b6b639e3e03281ee6aa4ac1619ddacc6c5cac83", + "kind": 24242, + "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "sig": "77d2cfa45456e28622bc4e8fb5a92f0b49acfd48b3bb2be9f06d2c8f800ce75dcf67abb46a4c5a376725153e3b5f8639e2788e830996604d0accc7c2daf994d3", + "tags": [ + [ + "p", + "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"d560c5dd47faca6961ac555b59674182815c1119462abd3e4b5e435e5b4e5d69\",\"timestamp\":1791465432}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "334708a718be8bca0387e6e40f125415966c68252c00c6442755d9a68b041d07", + "payload": "AjNHCKcYvovKA4fm5A8SVBWWbGglLADGRCdV2aaLBB0Hc8FIC/+iZDnvrA3PYbHZPlXXXbQWkbdA8tNfMF0fiDQ+nPFh6Y4XLatabfBeac4hp9wYN7HdjcNCHq5EZbxYEsCS" + }, + { + "length": 16, + "nonce": "fd8634caf4d7e7cf1097ca12e3da159942d9bac841e01ebf63b8b852f897d004", + "payload": "Av2GNMr01+fPEJfKEuPaFZlC2brIQeAev2O4uFL4l9AEQFTm0l91hgN72jwD50wgCG0w7kiN6Cn/zjBFcZpvOb1vpVKTcVTXP9oC5sGZsKhUoyFQM2XbCX4krYgsaNtyXWVk" + }, + { + "length": 31, + "nonce": "da33ab3992feb836cf1fef9c350863fd18785f7eab53ce40809aad4bb0234323", + "payload": "AtozqzmS/rg2zx/vnDUIY/0YeF9+q1POQICarUuwI0MjXdDIVKtEIOR5uchIelgLrD7spD5FhUa6kYOc4cjTcvhfgTpishRvQ5Wg5trOkTDLYNgLFsa9KwFIiWiX+VGk0qLR" + }, + { + "length": 32, + "nonce": "38ebd2c49e44bcfb0970bc8b42e140550b64ec743ed035552bdb00165c083193", + "payload": "Ajjr0sSeRLz7CXC8i0LhQFULZOx0PtA1VSvbABZcCDGTsVvvNmP2pHG+rIYuuxdaavA4BVbXqx7JQ9AVaoehyifx154Dj1XGhsK04TKrdSLrYBlcFrCp8Wz04o2hnP9nrvGk" + }, + { + "length": 33, + "nonce": "6fdc2a52bf5e73a461d2831cb4df48f4a32caec0b89fd832d5c31cdab3c85528", + "payload": "Am/cKlK/XnOkYdKDHLTfSPSjLK7AuJ/YMtXDHNqzyFUo22InbJo9lwKe7u9FEAIsPmQ0QBqSlaZfkiaEOoex6e0mIBlFp6Y8Zbw3EgjS+i4MIUVRdnEDQOmS1jgEFeYG09XFkVODSxGgq7emTSK08SbfwUB/nh1Jx5vhUX1hWIEzSWg=" + }, + { + "length": 64, + "nonce": "cbbfe9170917f2681e43ba1bb2908356b5ce4a774ff8eca7e8c8d83026b96306", + "payload": "Asu/6RcJF/JoHkO6G7KQg1a1zkp3T/jsp+jI2DAmuWMGSKjJWoG/T6SatmlQm0kdGw8zEa6s7jXykp/Ewok+FViOnIvScYW/xk45vWqFYiB8nPUVd0/mnrKEisPqQeIYhNsoJVDlmsJNEv/1pLUMRe2ukooenzihhpHpCB5nd2CuduE=" + }, + { + "length": 65, + "nonce": "62d5a7e4d36cf67ad1830c359d2ca3848236b5fb9bdaab447e3d2f15902bf1dc", + "payload": "AmLVp+TTbPZ60YMMNZ0so4SCNrX7m9qrRH49LxWQK/HcwBJRLGAM1oI8z8M4LL2MvxMi1xMBIcd3qPqmIkfbZqMfsk0gI43X98dY+WTvLNJybDNWCPwEs1WTmrC0fAxuTioxL0Z31UBSafAXXjqGxOF/Ha+Lx0e+dhgvaIQ83F74X66YzqREvcNe12Z1qeNMKw1UL4Ez0ECtrM6FitPx8LPs0Q==" + }, + { + "length": 255, + "nonce": "7ad8bd9f0730284c3bc0a20a413b739aeee516484df65eff2140869fb38cce19", + "payload": "AnrYvZ8HMChMO8CiCkE7c5ru5RZITfZe/yFAhp+zjM4ZtLwX7znP2d2YYuDHkfu7DZSA/RqBf6+MHRmnur9Xhe5ek4fzU/qOSoJ0ahamFObpCuQhVaNkE2KyRLVqf7/jUITctGjQdX6Q9iEkeVgslSneAEk0QpVu7f5VK+8d41xA3WtmB0fzStNYiIkyWJ+77GiayZbXCO2dNwAG6X/6SXzdAz5zOz9U594HUOdI+q/fqx7w+9qJiwVR8o2obsyWvENgUNC7hNSkSHQ8HAbM2NAOWa2xQY65Bg7L9X1Q8bZ85omuH8w0tiAoluEGnOv0QXWTKw37xuK4AqDOmrnNqu3ZTCAWdfQ9IooytkTWhtk1+Gne4dIiIRwpSNjD7kAUYbV2IC2YKvvbz/ApreoTD3r4IIgKdScmNrVVmZ8qW+3Qxhg=" + }, + { + "length": 256, + "nonce": "20994034195f0c00f465b8a249a57fb62386b061336f7f62fbcf585eb98e091b", + "payload": "AiCZQDQZXwwA9GW4okmlf7YjhrBhM29/YvvPWF65jgkb4Au56BlC78Fg1o35nm2C5EkuJWUevUn5btTTJRYhNENheKKHWdt6qWw0DI7b917iAMRNbw+CzsVOYZUt2WH/LfwXc+UR1Idd95vkLmEWffR911anfGRg2RYpY0UD3flS309bKrt+K5oG0qV9aCLZ5hlki7RSD4U1VAB20Eu6VIHd7hVMxcxW6nzqEZnco1h6WZnCKsCcQbkou+R6Pr3f5FXzIuOIWIfb0+B8vG7idznhyiu8S10Y2I8f/+89nM2igFWJu29bmV01aSjzZC9gjVrkbdo3XRu2tGeYyH1QsraeJ8eCnaNgJhkavRQS8fvbJ2REErh9YmToHpyTuAITkzETD7Bd2dASVmr1A7ggFlA3ukKAPM28XkbZ/X8iCP2m/y8=" + }, + { + "length": 257, + "nonce": "6f846db2b1b3306c3c62c85df2d2a09a043eb361a08b1a641d23405dae220690", + "payload": "Am+EbbKxszBsPGLIXfLSoJoEPrNhoIsaZB0jQF2uIgaQfuEULYwFJIhxlfc69Y2zR9JmtmiAdoPa5ZTOgkLx3RBSZrETfsV8gGq7KsZ6qkRb8494g7t4npJZH0au9DMDi7mjElekRU9sRykwNoHxjQr0/mdujzcvgeJUxHGix85+GjTFpqA0HhkZwdaoutmoH9TdJFry5zAHf4kAd3JzTja3Qu0Dk/Vh7YOJl2+JuAO5SoK2UbM5FWp4H7aNH/gKtfnOfQLGqQf0KpxkguSVhxMyQSh8gpi5t9668BqJsOdiERG2mrFHc+aXFzSQVRAIKbYcIvbIK4kp4ZmK8PcRTFOfFjfb86KvAhFedEzP20fVu5QAqmcAxB6MVEm8tDmWY1KX1CvsCHmHJn5vD0otqDOt82CuiTVXkFo1fGO+0SUxVn3osi7+//jRBrPsQb7eC3wHfxyBJmBgWXjntw9O4zgZnGfdPIOuZ+lANpAnTETxGMDDcJJydJsDfWwIvegBAxOB" + }, + { + "length": 300, + "nonce": "20759fcd458f324ea753bb352a6530e693b415364fd51cdee922259593b32b63", + "payload": "AiB1n81FjzJOp1O7NSplMOaTtBU2T9Uc3ukiJZWTsytjJq1eJGVkRj2VUvo7m7YLJhFkN4jSlFLmIj1GwjCDx/ucruqw9mR8io4+iQgJramwinRuowk7Ckxk7+kEH5uj1iYj1r7hSY1zvN1DdbCXTQy8QFIk2/JJWOqHHD9w0H8/K6A0BBuh0pUAeEcmal1iVMy5YbWRT9k9Fj5gtJBdcpNxPwb8EJUc1zgboh/2eMwp5atRQ3y9xRop1ZS6mXfPwvqXRZACbI/fIGY0yFqr28K35YkQjOJ7Zv7kBqn4YFLk5b9lwq2UCjwrPL5ZUHt2oclyiBobl+VKnCWdA3P1BpNykVW5pS41vCOSXETXFDSVRTjgKCeGlYtTDAkcyFQMA5te4NSafXv/sOMYsEaS/WSmtD/EfoT9AX8eSaLMMVX2tA2SFD33l9RvZTC2K+ij4/X9kmJVZKMiZB0oTxwNTed5XlBWPC6LQTDXaU/Rc2jP1v4XaYZs0wfdZPmGtIyXAoCm" + }, + { + "length": 1000, + "nonce": "aeb1d67705157852a1c1c2f953ff70f5a1f5e6370244656ca8b2ed383cde2b90", + "payload": "Aq6x1ncFFXhSocHC+VP/cPWh9eY3AkRlbKiy7Tg83iuQKWPczavFKKbkEEyZlRgoYc9Vh30Sdd46PJLKcBmhG16eDeh/tAJVbD69F5ci8JO8f6xNLEtqp0EtBDHwcM+p1pHhqI0bm+SAPbOLq4PYC6B+l4fICj2QXLVo5AZtZLMKs5PeRvX0pkQqr8Ymkst+Oafe/9xpSFw+dU1z+Ix/0XIRhVdQdTichjOwO5und1KG7lz1YA5yMMlhAbE7sHKX2+gdVHaFSGGkoMC9jnDiRYFZnhzUM4CwOtCMY4Pc3TvPt3POx2ppE03X8RCdzo9h+df+iUDJ231uBs3O/mQSYDCuflFH+bmQUMOZQJ1hQDhbI71KtoQTLEn9EQ3+ikw/wDVVFV+T0yzOepxiCLgi+tJ2ydmKM+xBVKRV8YLj6J6yDrMh/nV9NzWXESTZhfpphTqO3xVCPu+s0FiRU2P8txjoIBB8lpkhLADqgtdI2pwMxrC+cbr6kikZ6Uy8hs4jJfOHhlvT/MzVJ64gKO7gNf/HAq7u22c2voMTaIY7utd2kDZL4w/Dgo6YfxjtjjxGQSwJKPG9rtgDyOjNCcB6f101NRIuSkMFdpjMOCuxubahZkLxYetRVngjlzRgm9ateACWLmvz8n8U9iBz81/DZH1/o2UgpgaIUr/SeB1X1iI2rPT1LzydkylN2dFnJV5kHcZLMcdHSR8oWrekdmi9DL/NK9b2SbX9oRthiXhuZgxQksBDwROyvSpDQ+2MzP+Wt4UHFfKMZ7vVxa/+hRIUJIPZbvCHEY+WiNoXqaY67KpTiS9BC0A3r8DO+qLG/TUd9EK9QiAUFJabnu/OGHJNNoNGAJMfAhhEBtmgjrnSjGGxJhuL9hXgh5Zvfv15x6RF3bJDevzHzVcTWJafg+IRtZzeOP7UXwrfzG08IvfnC81JGyj+bayBQMpT9lHOSh6qtIrl3Ri5DpqzpgJZrfokgZfAv4+CS+q3v4tQDrybN3/0hRkEzURRy/8a+KIoD3nJY+T1PiSwZ8PFKxWSauKAU5YY7yP/UYB6OESt20oKonObWfw+zSHqiEoCXaqZ9OmKhKPw/D7vQEu+yiSIK/pwThn9FONBKEP5xkD/JO0I6nIUj1VeI2F6V1dfaFxpCg5qYf/1WoglAI2MpRv4ht2DtYHpKKTvG+rH/LBbMegI13XkVPvlc31ezaA1m0J5SV2fegMcrfsp5XLvUK3iXh1yK7JNoKTJuiNTSDFVVkPw/orngV+R1ryTgYCH7qC4OfYu+Dyxstc6KkESvHTGw4x2O516YbqyortGm0YBWvRcDCZVPDn31tRwNFHktmFX/9ubXW69I5vl0dvTCToGSrxpaxgjUPWunF7NgA8OQ7WmdFzfuskOb7a7Wj6IH/UGy3tfj6amR+T4sx7ClqVvGoOofd2IFY9feca1SP5NPa21ZoiMotg=" + }, + { + "length": 4096, + "nonce": "6a40e95b8496867b5e4002f7e91073b39fa6f9ad3c4bbb42b8d9d3b8896be991", + "payload_sha256": "e394e886cd9fe3bc03ec8f75131836e4ec1e45d71d7836048758ce0d138158a2" + }, + { + "length": 16385, + "nonce": "c0874facd941d2710768ecd778c7fa2a4a11047815b34bbed71d3a209a935815", + "payload_sha256": "3f475443fcfb61c8993b3df279f09655b181d5610a724522972f33ca1340cf09" + }, + { + "length": 65408, + "nonce": "dda1bf189af214614c5897f0e262559ed8de6aafab903bbccb83cd4c0922e485", + "payload_sha256": "b0a1bd6829dacfc658674ab528c764ec25a6e34ec1fe864a532a42057bdfb056" + } + ], + "peer_pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "peer_secret": "51a6b2c6980175a00c531d74bbfddffcd4bedea4b21d498b6a88c6785523eed3", + "proofs": [ + { + "proof": "f1f15f4cd93f3d6a46af02de587d48613ef2f3ea8914400c18a067d38cbb8a215b1285033daa06b1c8cc3a5b6cacbb83de963afa7143abc8c7be84ff39fc4515", + "timestamp": 0 + }, + { + "proof": "9cfa479d4edb6b44dfe848eb06c28cadf41652daf4fb822339a4f35ff6742118d7eaa182a3a84f4e892c57a371c711ebedc938654c5361daa94d6b8f9137cafe", + "timestamp": 1700000000 + }, + { + "proof": "0dd451a6a09a2a5f491209ac970671300d154527286f379659390510281690da66fa19444c97d84f467deedd7fe6159425642b672140dd3d03b851d17bf432c6", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + } + ], + "min_signers": 2 + }, + { + "group_key": "02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d", + "key_packages": [ + "00230f8ab300000000000000000000000000000000000000000000000000000000000000015817335811128ed1e6a7d552529dfd60c7ea131f5fbbe070b183721b681d748602a02b046a5c07f0941b33c032bd13f72551bfd87976daa8b902cbaa7ee4a05da502487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000021881ecab1bece4f3087a421548abdb1b4d658ca8e723ae1d1a22adc8f6dd05c903b455ad8e309d5a4f49ef7ef9c03ef04d268c589d6d8d3910f5642618852cd04b02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000039975729f42127b22a6fb7a7cf8a03bce1188e031c69876ac7150edd13b3e09f103403a4eddd79ffb0cbe53a13602a8cfa4cd0f36811cd05d7c87176863dc07ce1302487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000004daf1c53483835160c22b7e89627b1f7a59a530d34ed199e2f73bd3a7650a3fbd037887eeb910932a9c7973446335c1fabdb1911b0e833dd7abf944ba84f461724b02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000005dcf6e46ae03f67ad5a0a4e3a863c862025ba7e8d7fcf17c0abe35f4b7441a72d020f00ab70660c72cb08df914e45202c59819af901044bb30d882b969a1ca325a402487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03" + ], + "members": [ + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":1,\"verifying_share\":\"02a02b046a5c07f0941b33c032bd13f72551bfd87976daa8b902cbaa7ee4a05da5\",\"proof_signature\":\"9ab13b23fa0875925c59e18c13766126664fd3fafbc9d1d36022a7dad4004e242f5122f8839ec720f04c04a9e42faef82a37b818dd7289ff568442a4915b9b33\",\"timestamp\":1791465433,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791465430, + "id": "c46a37f295217b3b7644d1a537335d5ff874ab48d4e3db4c331dc64b060dd03a", + "kind": 24242, + "pubkey": "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c", + "sig": "0ca045e654db6941cac1a588db2bd97f9607f87a99e0a6acb3ae7502733e656d0518c555fed6ee107f1209ddb2a9d3f7e28c1a14a4af0e817bb1d574c300c8e6", + "tags": [ + [ + "g", + "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + ], + [ + "t", + "announce" + ], + [ + "p", + "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + ], + [ + "p", + "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + ], + [ + "p", + "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + ], + [ + "p", + "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + ] + ] + }, + "events": [ + { + "event": { + "content": "AuotT1raNoWzq20B6zPoo+h/YaJbWkvVeUaQr5lEO9dENK07UTshYu7gRKUqT9pDtLJD2ij1xxid6YUVabyEoHloxnbOrNJ91wSB9QOE+0biPzldT6fVuamKktC6ug7NiFxwcKy3BVVRgKp3ptQnMhcY4iTzZZrXvQE4wc2we6hUZzdNB5JXKmmb3lXkzL9VUftmR3kp2o02sEpWP5kwaFlSpY+sf7cz6p7oKNCjLDaFLp9CiD/2LU/1uMxisHnSiyYC", + "created_at": 1791465432, + "id": "fa503ee84f39010295fcf681c1a040c82e6fdd399ecfb5f7dc2e1de4244f1ca8", + "kind": 24242, + "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "sig": "200135f62e5721a8b7048133bc25c91b8b93d631cb2ef57b3de5b7a33cce039153820b2b38adeee984a73e492629e20ea71497a09a927c7d764f7f2c72c3d6ef", + "tags": [ + [ + "p", + "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465433}" + }, + { + "event": { + "content": "AjMvpJ+zSO+ZQvuz4yazYMqPHpWufC1UaH9CdLhs2OVxGOdPqNrl3jTEh0dpg8X9uqfRGDMKWdmzR94BrnlvSgcAzmsBiVAwzHLkSem3cg+I9z4OQ+TR7hdSgieUv0Xkng0Bw9i9h/N6oBggIvVYYX5zxdvMhQT3Cxyu7eZuEVTj8ek/PTg6wNRfO3Y6P+E9Dfe+sXYGfGx6v/u+r9Ge8qxHHiHcCcMeO0TiiOTlB0d9jnUjv2WO855UT5paZLwpqj6D", + "created_at": 1791465430, + "id": "a84e34840a8b95f0936d76253c6f29dd41d9d12638244518f951fdaf5f3df92d", + "kind": 24242, + "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "sig": "89a56487283b0b00e364cb976a140edc0c9ad274d79455b2dddb44b1c27c24f6b182c9298f5bc7c6289707faf33bfd478b485cb33e2d421ea5d95ce7a5c97872", + "tags": [ + [ + "p", + "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"b26e61103edebee548eed5db73cfa8b64741c178f77b0fbdca65b71d5abacc8e\",\"timestamp\":1791465433}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "35de5f95c9292fc722aade90df4b0fecdd4fbf49fe9fdadd24876a3eda5d44ee", + "payload": "AjXeX5XJKS/HIqrekN9LD+zdT79J/p/a3SSHaj7aXUTu6aFxLmJaD0EsHyLoXdf6RhJNN6bv63dpk121SaleIOj0AdyfTQXrJnv8KoPUoS4zb6GygOryATgSQkNljvJRAa51" + }, + { + "length": 16, + "nonce": "e93d958af5dd6cdfe73370382267f2d811f7f63fcc8e81d7fae888daa0e3dcbf", + "payload": "Auk9lYr13Wzf5zNwOCJn8tgR9/Y/zI6B1/roiNqg49y/od3vHK2FpvWjwC8VobBGQbxVVafADixICMvpIwted99FA0N+I3hzqcrTVhIvmVFEqkZxoD8ZPV2AMW5i06nW9ALJ" + }, + { + "length": 31, + "nonce": "53ffa6c0cd2fbb0948dd600605cfa2217089270a72d46c1affe2b99420533aa0", + "payload": "AlP/psDNL7sJSN1gBgXPoiFwiScKctRsGv/iuZQgUzqgukioFUiEm5ZfTrDhizizDGKFJRO91sF5631JrXJP/sztS1aeP4kGWGs8PFxlxQXJ+OItVcPxZjeGulqSCmJoQOIj" + }, + { + "length": 32, + "nonce": "dc6c91f26e9727c63d456dc955671f8a3ff8c737def22bc80b98218f13abeae3", + "payload": "AtxskfJulyfGPUVtyVVnH4o/+Mc33vIryAuYIY8Tq+rjTQd5yHtSore071JO7LhTpbF8JXXpKgaK0ugI3VD13F8CjC6FE2fjc/baIWmBWv3Q5pQ7Kytlun9CK+LG93f+78Jt" + }, + { + "length": 33, + "nonce": "2f53060be3a6091fb8ea2c200f2726eb042d46c9322fb4c588c43cd7ad35bf3c", + "payload": "Ai9TBgvjpgkfuOosIA8nJusELUbJMi+0xYjEPNetNb88SbmzvU0TdkhnI3YVBVOlJk3K8rDfXQ0qWfUM2yH1/kKcQDjnPjULRXsA514tr4KkYcFv/MBxD9Mikeb9gaalFgwQpZPXbO6qYcJ7/DN5+bZocR/ZaeU2KeIVcH2ekLwr7Ik=" + }, + { + "length": 64, + "nonce": "56652b68bc15a9ec751dfcd5b9534ff2982b173472c1e851f925074738c0dd9d", + "payload": "AlZlK2i8FansdR381blTT/KYKxc0csHoUfklB0c4wN2dYzU+Djtvhrn1j2rFsPO+OMQ7UHtaByE15ToTG53aSixqEXZt9bEEJ/PL9HHWIZd4iolCR/xdy1jKNdxxHGeJtEuXxzNMIQ1TaTu8vf6BzWPkmqa+T24n98FtLilkJDt5GC4=" + }, + { + "length": 65, + "nonce": "e19794dbbf768d6838ddab2711eb037a72656fc34a4869f63e605f2451c2f09a", + "payload": "AuGXlNu/do1oON2rJxHrA3pyZW/DSkhp9j5gXyRRwvCan9OJ3z+eh6a514hkckYfWKZkPpaGb9YaLfbTXJUFpryvmX0WZes3Gz6Gx3b/VH00s6eNUrwUhUO1ObNhK/InK15H1339RX6+Jy5CMfcjrGLAnmrIZujxaoP+mHQZ9pN5v6BMybpU1sVeY3FVFzR9feZueHAlW4Zx2yOaC98VmL/odw==" + }, + { + "length": 255, + "nonce": "a7c97adde5a52126d39edb1dd425756d8d49a6de7c1afb36731a18ccf426ee1d", + "payload": "AqfJet3lpSEm057bHdQldW2NSabefBr7NnMaGMz0Ju4dGMoTN8vp1tQiwKUjEtKVOY+FKknzNyVB8M8yakkfN9rSoyc7K0H8FnVYSnDdceqZG8XgC1DGblnTrS4j29VFcU3WOkcqkvR8IG+cCmACRpm/eE33G6zgdEqxNAVGVRsqpcBTKEdnl4ip2PEdBUOmbDbkmiyr8NMvHhZo+mHbdWT0C8xTvrrJBb5n2srn3bDat+8ekbS5gY+3EmwBIPPJeno5KLXJg/Dt4/wWI/s0JzSv/YjpCsAK+kVGejcq0Fny4SnOlCFJ9jOzKqmtVHtai75rUexkKDiexozGTStwfKMigQ3BmlcDXf9W+4xtjl2ytLh4GY/WBWmOpxbpYjAIexkRK65KOB81z4QQZwtnABLjRm/Xs+rgdPRrmLZRdYh/FMo=" + }, + { + "length": 256, + "nonce": "9dedded080b305808a08622ae5d038a764bafa0b95047827047db26141184b7e", + "payload": "Ap3t3tCAswWAighiKuXQOKdkuvoLlQR4JwR9smFBGEt+JBHKRxXt5N9XresmCng1trYmDyv968xRuzBtHRYgjypiH6oj9nMUsWq2NjkkvrWSex+KSN+wv5CGwLrldBKhXWNYXxd6lICjAZWz9tDYQMmE/f7d/9YRxPHyENEU1DtxTfueTGKUKsEUxENa7yjrEXqgp0sZYYB9Qr7zJVsmUJO96ecppS0Qt1g94haSS2VUhUora04QKqe8k+fyM+8O9lehFxNUJNYEiHWlcen6MoglXbYqaZ6cQ7L7rzSjs/rEqfb0ccCHnHbKwz7niMhTAJJt0tdxOSjLOgQnmgXpKtidX0ADpUdhTdcCvIAMwwJJRXeaLLucEWC4G5guYvDSfuQ9r7aRmYKNtynr9Eg3+ooO7BiVKG8dIp08J7po6dhVeDE=" + }, + { + "length": 257, + "nonce": "9ef8f1a39d116fd891bff7abd67cfa4f82be42d3ac626d9375fba2c8fefd96d3", + "payload": "Ap748aOdEW/Ykb/3q9Z8+k+CvkLTrGJtk3X7osj+/ZbTt5nLG+NE5CyEF3SFbvdiOlwHbnzjAbPy9dmdvem250azZq4BNGTbLcbXKYoux2doPEkzKqWrtfhXbrtn9XIzMRn3kcOTKqt1I4/Le+SOfw2lzdYmeE0IZ6DQNhzsS8c6dXZp+XNfwJmPAZbZc9cKXMwqPaINz8aVQ43CUkIdS7x6ATHHEck7K2+MnpD0M75oMBVNG2DbRTd8K+9GAMJNTpCUg5VigmwZZZoRaGi858JnTzrHq8t2ZfZvNBajMKk7yGseysVqEmlkVivwkUX+MPLPoxZRVZv0z3iCFj4IGmA2Y5H1U+rHuz+FW9E442LGSJvBZY8nAjKG4U3AFzYa+Nk83dmpFeYnpsdO9eqVuRv1JMzZj0yoUiFZO0j1v/FfTBU4vBRyqCra01S4gt/7MDymxFO4bSi6RDYi1B2ARkg52y+U7oS5DSaDxLKtLfXfpcGD6ZQIyaHfVNY4zxNeUsQv" + }, + { + "length": 300, + "nonce": "6eab9ce69de78202e8cc7f37da0e840309039f1101323b9703c88abe46599bfd", + "payload": "Am6rnOad54IC6Mx/N9oOhAMJA58RATI7lwPIir5GWZv9lF4wSQtMZLDKQJs2lWZnK70P4BygReluiV4DMLqZV3Z71YsJBMogGDUHpb6HpYDxyYFiyhkSnMSMJzKLQtOzYmWsF/zeE+XIbo0UdcA8owkzSWbtE5k/qT88ZHlooZIJQQ/cw8HM3dK7+FB9uk8QGQCFd2+GlZqf+q8WvBGZ3KCGY8IvdKPZb6v6/xazFSe2FtbcfBKIx1XkR+Xd8NUhphYRctXBF5WZRuj8R+PNdHvRikERZTcDVtaaV4wVg9HTlXO/PJt92NPlpkzw43VnRmvIWalkN358NMWXM6MTAyB3k+q5V9HzuRRAoVI8EEk/sKhvYew4+58DW5bzhNJtp2Xz5sfwR/kA3AaWMqqN6JtMQfEuyvKblNj717TeHPRuQ4yuZ+wr1Kf8U3TYFxmlbzlIaIIlrVgPOrDvRGxxFTQtkTQZ+B0b9EdNqSHhKxj6OB7bJGm4YdI4ln2S+dawyAHg" + }, + { + "length": 1000, + "nonce": "d79c54d46de6666f32660ed419ad942879f75ead7edcffe0912a7f0a1f199067", + "payload": "AtecVNRt5mZvMmYO1BmtlCh5916tftz/4JEqfwofGZBn+Rzo88AvNSzzDX44IUcqt8t04uIVL+yjqE1OJoToRvL+LKgndc5Aaa6QVTnjqvhpV2DUssryhrzdvF20LkmWy8rFADcemQyr6RTmqFiPbm2Ge5FkFaPx/HAGb4TpjdaZlq/qdJvQtL1AzEvhMpwCfOkDLg6oy7Ws6unuGwMeIIJNcIWQqSA/OohO0BYgqq8ZnIWUwEooLwDEFX4b9TC+mwteou0kKH1MT/FLjAfL8RyVL5DawbGr6Fq1xkt/+fTrjiOrJebdbvieuJDj1Awh+r7TA5+kHqA3epQg7ITjDGTRFi9PiPxdOnf6wBChot/DioJBZoVMEIQxlbWGhTE4+DY/lcOFq/xxk/gnEjekxAzSf8V2UV99MF8KrC1E8fgqRpBWxWy6t7WsSSSNdlpOMcp2AvQWpsu7t9/ki0dXjnad+kYXsQfAp8dlRAJHBRzqJN+3iSC1U98sQRdhECwQgx1A9vMcCwmZC1oKxZqDU7CN10xe5XvSMrWS0SatiihUUSzq25f3vWPyh++11BB+HxZ+I6+XcZXz85lJV4fx0rp0Q02JSmsKFpT2/3521ycybqKLwHAzdIQyBQ57HdaZIdp/Cv4nh7JIx471Al2ftEpqwAjjA3VgudWXDs0aq8Ia1HM24dR8KUL9tLyvaMN1H2gw16PkZ+ht6IZyNMgSeu+EpOS13hDvn9BaI0nD2DnUh265vt3uPqu6j7s1xs6wV8V9/4BlpahwNljr2v/ZP82dT5a5tfWxjqBKo4bZpWrwC5fH95G4iTJCmMQ3dU1h4GyR7SYhDQ0kYWZb8FhI8DGWPvUdXIkizLhxe6X0iQcRKx07Zc56WfgVMl6FGoJEQm6wc90U8uKzX0TDw2q/myQ3T6+SRm2oeQWQiJDuSheI2BSF04noeqbUrgVaaCM0AVnSrb2s9JsjYiDbwqj/H8/IMs3BW25BAHF4JsDLFW5O5vJOl77n+kiFlFfwSVyCE+GOGe66WZH9mSn8X6d63Y46I5n85QkJZec71w+ELtzoGSXKrgFLENf23d0PhMpEyt1lCXu/mjFa4e0bUzjGSOw0e4GHxipSHB0HQJqfOUCVnNjk/W9Z75NAwd/2kV79eYZcTEuLzI83D8R0UgIuXG8W+9V/SBkUu9ixqL6oYF578rlJPYLa+plOD+TOWYF95fa02vcu1PY9Br1fOP89UP5MVUMPW/QI9S7uvAlYX0Jx3RzE0pUdQJkbpjaXse7dGt5pfsmMYJnd0qpShtrZYJHTo0kIoLHrXXLiXX66mYOTOmI2OLfnm2f58Ds5WcaaQDIEMewPZdnXw9uofycbdwWd0tJhQkF/cOfv5wMJ6rrMe+5bNrGQIbh2awIJpJs7sVckUs57AoCBz/uU4cWGF4zQyb6Hdbsz8jDdCrKJTyuYRYg=" + }, + { + "length": 4096, + "nonce": "b048e3362e0981b9767a99c6c485e65329c5d1248f3d112104303fa648f6db0c", + "payload_sha256": "ed2bf52c8ada5d1cc30cc7e40b9f830e8c869fe7d98a6fd0ac911350b1177f7c" + }, + { + "length": 16385, + "nonce": "46b2f6a60d194d6a689d8d0fe9b7c72c79a48c118f90e5ad14974d9e107868a4", + "payload_sha256": "bd4bfda45dadc33cd1ba04cc985953b60e4383f8872fa65a871a2fab24efcd99" + }, + { + "length": 65408, + "nonce": "c3d733c51bd5c2ffe2b8134ac24cbebda301d40315d3d3c09860b048905bf333", + "payload_sha256": "438d062cb3642c1e93f5af6f91c2ca77720a0f3d16737cf55966fe626ebe9672" + } + ], + "peer_pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "peer_secret": "968b7a8f13cd22fe46e2694bd9324845bfe604d7c259011b130ba45cd2c3d70d", + "proofs": [ + { + "proof": "b1a4427751725f0cb43f58f73ddf8a1e00672c557961b87ec688f0c8056e3cdee6af61936f0c0cefc5d4acb7aa0b66e01754e87d0563371a65c4e766e471d6af", + "timestamp": 0 + }, + { + "proof": "fd7628c25c32d0e7fa0052ae242183c82b2b2377116ad633ecb558744953207fdddeaf18714713d3143a404a61cdcbd47f4df22271b3e6ec24dbcbba3fbac6af", + "timestamp": 1700000000 + }, + { + "proof": "b7145433d4e427494fe0557dca4bda0076ef1231e0ae37bd10558d0ccd47154ed66a3ccd9049582feeee681d390f9b38620533efe5c281af86a53dd4b3601a82", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":2,\"verifying_share\":\"03b455ad8e309d5a4f49ef7ef9c03ef04d268c589d6d8d3910f5642618852cd04b\",\"proof_signature\":\"f257316a7736945a80eefd7f62baa44abad71937b35a5d534b9105cefe71187c132dfe2eed7e65f1c6613b8bc890da493a20907ac70db9ee661bb6bfbb7caae5\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791465430, + "id": "bba8d4cf4c94ffd8502c1b6bdaa6ea4c67629be4ce893b5b13b2833fc16d1f30", + "kind": 24242, + "pubkey": "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d", + "sig": "6308bed8b075f61f07a478a90e0d898f3b2c32e78575076926ff7b37ea2e0cf178f65310ca41687f34552ee3193066c239b8f13c5d481dabfd93c66c29041df0", + "tags": [ + [ + "g", + "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + ], + [ + "t", + "announce" + ], + [ + "p", + "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + ], + [ + "p", + "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + ], + [ + "p", + "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + ], + [ + "p", + "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + ] + ] + }, + "events": [ + { + "event": { + "content": "Apfz+rLZ9S6B9vgewRvhLc+QDGlmpywC0YnLq4R4hgqdm7K+0emyWti3j+SeKmiEmSPtLBIA0kboG2JymRJmkfTCJ4U4G3jU8OGD5D/PXyJtSwpHYP5zA6T5l0yP0Idt24R/mxv8i+BkTKcydRIZ81xaNSTpQEfA95spmf+ovmAxjRCjFbGgz8NyezfsTq66A+SN21RDVWSBhKuAeIGralQwBUKb8GKn48wGQpnxyt8WVY7Y/tcQCncIeNbcghnpKn7z", + "created_at": 1791465433, + "id": "51a5d08afb67b6ca7925b1d0d5dda964b3c24659bfeebee9edbc45f35d7da5ce", + "kind": 24242, + "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "sig": "97ca451dcd484776604eb1e68f4ef73ab7bfc112e5b29357af46dcf327e9916a84e33e8214b7b97734ec5e6e2bc4e1747b5b2a8def8a62c010955dbb5c0f59a0", + "tags": [ + [ + "p", + "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + }, + { + "event": { + "content": "AtXmJaKJbSf4QDlwMBXJtMqhrTtiJyZyG3inPy5QaO9M8/hppQmM7JcS7gO6n0vmxAVf/OisYotzKEc9DYJWWwsm4pGArpH4yQL0YIqoHBC3chHdhtT2SskwiEyFZSGUFqp3cN5KZK2I603M0ULF70JCzVp0Thd2f56Ajkr+9DXJnfB9nNdaGmq08VP4cdMQZSLZS/646sHFKFXG7zA8pdRgd7/1k3FBcE54hGD02a5Ej96Crvz9TzfNEgyTjzFGO72A", + "created_at": 1791465432, + "id": "52e2a5a58f12ffeb19d437bac5ab77caa9e5ce1b10f89a8c9c3ddcd3cb49dfee", + "kind": 24242, + "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "sig": "6fd5a9fc0ed3828ae7ee164c1900ce9c5455c028db9f04fc4a8b24cf8106759a8bc966205d60657e6e0c7d89cbc7cccd88fe6b98db2b860134983716fbc9e8da", + "tags": [ + [ + "p", + "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"a6dd1d632f6566be06854b2c112505bb873b78ba7ac5f0d08afbb384ae9b9054\",\"timestamp\":1791465434}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "c7cc4ebc48fcf9ea4b95013bda8d13261f64aaca9cbd1a04d35b7b08bf9cf24a", + "payload": "AsfMTrxI/PnqS5UBO9qNEyYfZKrKnL0aBNNbewi/nPJKlfTUNuSusOsKhJ35Ifw5vITdGXPZtQcDg9jcEakxieReFsPd6oXW9jVLV2uVvwnzZQmO9T1u3uIsgjqYcIHrCmn5" + }, + { + "length": 16, + "nonce": "21fe3bc66a60a3ef2f02ada9c91b6b742f816b5a62fe2826643f49a2ccd13d93", + "payload": "AiH+O8ZqYKPvLwKtqckba3QvgWtaYv4oJmQ/SaLM0T2TUutqLz7tykrO/0oaOUoWTmscIO770J31SSGdI0De1B2qEzp9fraL8z9u4vMmD1aKlLjGhuOByyRqp1vcilrLdkqz" + }, + { + "length": 31, + "nonce": "ad8d4a308012ce84b463f1c0fd2896a5346f777d94db69fdf7b4833bb1364dbe", + "payload": "Aq2NSjCAEs6EtGPxwP0olqU0b3d9lNtp/fe0gzuxNk2+FJRbE2OIE6zmW0GrNSZisyaTWil7g3OU/9OR6EhEgFyy2G5jTdUMOn2yQgMolkncVNezBlqd6n1+lAQo9Fzg6Eo2" + }, + { + "length": 32, + "nonce": "f23e86846416e77c79c013877140d442af1c415f97ba08eb31905803f86eb903", + "payload": "AvI+hoRkFud8ecATh3FA1EKvHEFfl7oI6zGQWAP4brkDrhq3GyBYg7oQCR+sXEp+suHHV5qApbdtE80PvRRmijlBfaiC66h77b61ATdzJoi5Re5Nu8w74KR17jmwtVX1syS1" + }, + { + "length": 33, + "nonce": "d5353cfe6c1f62a506e97593886195a2d6d9e1dba2c54014d06f48d732448143", + "payload": "AtU1PP5sH2KlBul1k4hhlaLW2eHbosVAFNBvSNcyRIFD5z79Go0dLuFSHmN2QI+uw5PaWNd1gi+nGvioC/ZJWhAMtTpskNhxWNfhSZ2uHwDg08u/PncL0JbByKDbPugrrZz1yLNreJ5F1cfNnACXuvYYKWvum2mUk/UT9QyyHY8M7uE=" + }, + { + "length": 64, + "nonce": "12abfa87f5565130cfc5bfcab930bf2116de8cbc95e5d1fa03f71c396f0cd19f", + "payload": "AhKr+of1VlEwz8W/yrkwvyEW3oy8leXR+gP3HDlvDNGfNTfpMdlJB9oeiXTbPHsWGq23wsYaDarszgLX1Fm8aMrvep7lzSIL5S5DOg+iOVtM9p/npnbKaSirMXu1zxf2HyoxqaOM9q3ARuDwBLcfxseQ8RFcF+ZC5J0b0DU6e7Vnhqo=" + }, + { + "length": 65, + "nonce": "1e1459b28fcfd4d6baa69fd2641112cd2098058c42adb209ba85633b85618e6d", + "payload": "Ah4UWbKPz9TWuqaf0mQREs0gmAWMQq2yCbqFYzuFYY5tD8VLCSkrtxoRnw2hsBBh9gKmrF+HXQApA5Or/a55st40nQ6SATrm81iURz/XCadRlA+7EGquRcHSIP2D8U2Mlb47rVm/r3SIdym42k1WWfolAv7LonlSQKI+lZqAFtDViqOsmiNFZBszZJc/bFCd5BLTEJMCZhgST0eH24Q4QIHykw==" + }, + { + "length": 255, + "nonce": "335abeb1a24fbc00e9cc5f89cd10e86ca5bd6c2258359b998c7c6df0e5aa54e2", + "payload": "AjNavrGiT7wA6cxfic0Q6GylvWwiWDWbmYx8bfDlqlTiUKTaqhGkJAT6N4XpPCS6GmodFRQARYFskIPdjmIyGWlZDJyu/mI4vSiuhaeZLj/6YVZVWOOqOH++GHWdQVx6qf+wfAy27p2OMKzBju7ixUvX7NJl54ra8hAnAApLENyUVVeC50ggG4KqdijmyHyBcLmWEUAH6dXaHEAFH0EW7ESVztsaHpW1tWEfL4U4yZe+U5WD4clVMjJtTy3m89IL+YemvmG3Nhpo8oQtIq1Z8Uh8kZruQITbtVkpOTNSi/7Lh2wSvPTRUrAHas3CYTmGIJMJulnR0P6RwFYnZ/b54a4UOl8AWU64//wGuWnqZn1fyYpeb/L6dikn3GDLQjKpKjetQ5h6QSW+lxxq6fWiykyBvlnQdp5sa+p6a/K/3hu2CL8=" + }, + { + "length": 256, + "nonce": "a003d16e5681621eec12cd4d490e577083982c348a9ff0a8c79e5f49b8daa588", + "payload": "AqAD0W5WgWIe7BLNTUkOV3CDmCw0ip/wqMeeX0m42qWIl103kvF19fzphhWzw/+KydpZq4+PGsP6o+Rmof3E7S07MG24CtP8AtvmIdX0pbB2QrVGlfR7IOWv0P5sWBUs8uDEXwxYGized73RK6+yxMLYb//me2pqdMJvF3ebm8devg8ZJqEm2O23kPSow+F1wOXNlTgJhqKvGynAC62Tub8FkyRjCfamdHQ8ZBjC0WmPiXvPaOUcIBL/fcjG1n8qf8JooAmKKz55LuGDP34nvqzRsO/k3Xy9JVCBJVp6EC/sEsD6u0yIhgCOfJP7XxcxMgc3SoAPISi9UIK4lcWkg0kZu56FIUnx3POVnGNvNAyeljjf1iKA+jrgx/kUOEG/lCGon1YN5HflQnEkEPidYZ0O6ZeqD3Tofdrr0WC4sfUhgBY=" + }, + { + "length": 257, + "nonce": "59605cc1c103b41ac91b2334576a322015bd170b5445ccff345961458078aae7", + "payload": "AllgXMHBA7QayRsjNFdqMiAVvRcLVEXM/zRZYUWAeKrn2fga2OmC9dyrp/JxMPOKurLvASHggTFXeKPi0M+xk9Fe6kHNBx4sQFTut7Y3wG9r5GBxDn9wfQCQwRGn76AI/9+S0YPsyJojHhabMIVi9OfkjvvdTqZHuQYaTSrBxA7TgkV7RrLrqqouy5xmFglW3YIQ9qQ7PWtG7w9KK1qxrSSCwFT778vb5RAjSZj6KmvQIowP4Q086Ag0vkMQFbzI8q2OyXw/2PhiO+Z4xrif9rQWkvcf8QwHd1Kb6TQ9+1xgZJR1a0jtHTvUWHUlRQU/YvvIRxBuagPeIpoF2LU47Dc995eeBMY9qyuOZSXHGsPaCCKs9i1qYyHBifc6/nZYvIwFgwoFLglcKtBR0LqYGNS+tH1itEaoPTcOUzVcuobOlAVHZOtfQxoQPwrOqYbq+KmVXaAc7WBitD3KvTdZF14ule5qKbworRHz3fEz1IWBqTeSh5fEIBCoS0fiAVjFNiCW" + }, + { + "length": 300, + "nonce": "cf4e1221060f7345f007a1b147510a718df7c812badb4d42553a2a01ba923825", + "payload": "As9OEiEGD3NF8AehsUdRCnGN98gSuttNQlU6KgG6kjglQaAElEi5m88R0m5uuzU+eYRXbDB1EW+ahVuWd/Kc90JzppzRsrUAEC93dDRdjUp4kufO+WxK1r1oz/y4tl/Q6Y1sG042/b1Tdr+2kpARmGO5KxpUKXYue58xK1uWVoedCliVCojucocVzNbCsrBq6utr4WzJl8rsyswKzV5V7kHFcAgkkL50XO2CSdcFdBcCY7hLekZPi3/wahV6bsHrBOlKBpkWRe0bsQ0jeyQy7eEf9llI7xKnSWXA03/fJEoevBJ7VsmAKBx/SJoHz9WMZUzqc8dirCIsD8Gj0J1+ozrEKdBssA6XECZF1w8a8A4+bwig6l8yQPw58qWat3DHYupfC0kgGCciqenLNxpI9ec2Cp+nnA1YNwiMt0XMETzJOm8ocsDdmJxu7ZRCRAIriRPwJyvAE2i9vD1WXMv1Rk3fYrLY52AaNqDTWMuaidXbrf4QpiEIGxeVrQhme7u4kGov" + }, + { + "length": 1000, + "nonce": "51d3925d76bde2b2d53a2b8c285f14f1870cfa3264c6c209ba84d0758c3a2249", + "payload": "AlHTkl12veKy1TorjChfFPGHDPoyZMbCCbqE0HWMOiJJClTOW1I2+ccU+Jftmryepqubm+cZ5YHGxtoUoqgE7sUfOeBNJY5jknx2tLiV6IOcG4g6oqbP0OGM0+YmCVXPmb+d9//MmZlQZFMq7xlFn+cVMLKhtVVNx53rrMJuyPBdb8aGvXEqaHmhr0XwBsqdn4W2QeKE06Ef9kkpWwcpZiVoAJ4eeTEg2brXAp06hfFn9smBk8GgvOUaJmaCBxVD7qgTRyPg7S5msNV6jjJGfnr4eRdfSrMvh53HDAXOf0DutphSznXv2L5F2EE4GzR+SLw+JRr2QkIyPNOIIDNuvFpjHlayS3xOkvCW39ppEfDzwXgbBAHhQDBBQ5MAtn5GJvoZr87IT6TY88a3ml/HLUkazfebKJ/72xROh8rUA+2KG5E0kxVgxWBbrCEAOveZM585AAXmZ5dzmGZfH7U1/xfs8QBJSRPFVMpukkT4MapWVN8hTc71tOVBSXAsxZ0rvEw3hDNjrBjCc5p2tp/jazgN4tBB2mZhDSh7DuVgqE4y7Bh0tHj5+HwnVkXmnPH1N6kQ2QuIa6AwtB4MbdOrvRG7xeZiiYjJtSfnznqvgeQYViuMfqHUqD2t0C0hO37ao4vWdmbyQ4hTY0bQlbBpKtSGK7vwEcpFYN/S9rfBbRbgDtV/BZ4FSssy7nmtBhrVaPRb9ooko8GhOCOwDP/WdDSmcJ8xQwYAXjWxIQ2z948oXBJIvDPzAbzBei+cixgES9KbRk+umQWYf5Da1Jr58rU0Ms+vrq1TMTgMjEKcQhIn+i/X9QDq6CnefCaxP6CXegyZzBuIGJo7JkSjTupiPNFNP0Zn60Z0v475GW/HqJKXcHEqo89Myhf84JcehRuxrYUHC4Ra3r+CTZI7JF3RG2HStSkGPgpcDEg5jX6vQf/xEEwWESkHrzN5lNqqyQPQ5omt1LhU3V4cgUyMbx/G9vegQZN4BZrudDoSzs9XZZArJGkNpFdt6DRv/td+TekM37OcjzMNHOznMEuqcQRYuaGVP/S9w2kww2uVok4kV4rIJzAsIw/9S3SRwdDLWSS3SwQ4WC5OGJmoSlai3OxleCghi0kwFxsiktb7ikwwE12NkUFyWIyX0nSBOfzenhQkjj+TDYLAOKsq5Dp0AN/f97ox3sIW7h2kFBoSkg0V12mWzXrWTZSEdMhMlFN7ofXxnJ38VzSRuYsd8hJn055phUEAxq0CH8sPq0sUXFPswecQxFH14PICTkWcY5JyQtK5nVOmzlz2PFQMlmTBkf8zDq2oPavgQ/lKyJVplT56foV0j8uymw0iy+UXC/xVJvHI7U/17TqlFjQBVZPIm9XB5CUZjWZHBv24kvRD4YXMD3KRTtfOD8Bg++BGbRW7+1DjCMCtsYeVictA+/AiENWJGJDo5EOhSqm6eJ993o8Xxb1qBTg=" + }, + { + "length": 4096, + "nonce": "a20a6255ff310bf92ad6eb8688687b01be27612b2826b2b0f158ac9c7a75c4b9", + "payload_sha256": "e6614fb0faa055e0cd02ddce20449d0cc6f05fad7c0966822f03890238e6ac80" + }, + { + "length": 16385, + "nonce": "ff3410c7c0b3ed2782d7e27ec7f2b16ad2716a8d0ba1506cff2717cea83891ff", + "payload_sha256": "6b5b4c0a34626ae72241921247736138e8c04b64e0f27a06a691326a42e665d5" + }, + { + "length": 65408, + "nonce": "bd7fee018080bdcaf386916c733834ada1b438b8341f24dd9328cb983eaa6a94", + "payload_sha256": "f198aefb3f7db5d05d7bdeea023f9483a45329ce66da79b91b097e42061116b3" + } + ], + "peer_pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "peer_secret": "b690c8608bd3d48ac4f6023b22139fc2e622dabe720b0699df144f3c5f279044", + "proofs": [ + { + "proof": "295deee9387316b3980c93b7429003a0e30187773c8cd4a6e64f7814c078e2bf25ec232150571f84acde7a9b7ff10c6c62ec3a12f6d5d0c11dad3ab23a0e3f83", + "timestamp": 0 + }, + { + "proof": "6002674cb570df23e93ce69bb92eaed7ad2cdf6032bf33a727d2b54df57889d5b2345cbc451547bbad367bb24becf81388311d205ef7eb3e319a724ee8ecb0cb", + "timestamp": 1700000000 + }, + { + "proof": "d84ef2ceae2ab60a58ea16e9f6a81095347996f5f5dbb7149dc9ced6b5aaf14a8fc7d7d34072cd1fbf3e05d20f392f98bec854179b50d60045ddd8bc2c5493b9", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":3,\"verifying_share\":\"03403a4eddd79ffb0cbe53a13602a8cfa4cd0f36811cd05d7c87176863dc07ce13\",\"proof_signature\":\"a865875e92e464000956bda68754daa4bb9175b3bff8d431aeb500e67d15a22fc179af7a0e3feda41a80d1a21a5fa7376f4066f498651210154568d49789d394\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791465430, + "id": "18dea5a4d675527285d8886a775670f409b19aa3e2dfac96dd0252cd6751c9f1", + "kind": 24242, + "pubkey": "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62", + "sig": "fe22c7f75182bc4fa4c17ca6dc830297c2edd1f0622434c090b2a22db440015067cee8d8e418e7f44491b98a2db91a0d6e636bf72b8f3283bb1c38b6faadb684", + "tags": [ + [ + "g", + "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + ], + [ + "t", + "announce" + ], + [ + "p", + "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + ], + [ + "p", + "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + ], + [ + "p", + "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + ], + [ + "p", + "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + ] + ] + }, + "events": [ + { + "event": { + "content": "Au2B0DTH2+zaYDnz45WRRAbIFIYqKS2Nb4oOvOV3s7t1aKawdZHODzWia7ei5uFw2t8BRVoz2dtYxMByQqvZOueCujkM6qTmJH0/nSXJVZRkKspEwEw+ENQ8fCZA8ZqOHh1+4QH6yYIf0/DUrm9Lnim95wUsvN2uvi4MrrFI1G2wb8i+bH3EjOyrTkTqhHHOBCUye57ZHxhPTFMECeoH80gdxExQm1hgtG/sT9J1aBaCvqU8uCeZmyyAC68EarRdarzG", + "created_at": 1791465433, + "id": "a87f6dbe5be1f396cf532d155de6ce2ff1d560bd0a5ff1433a722b336c0b59d5", + "kind": 24242, + "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "sig": "3cdc246104ba79487603c82d84bbba19db5eea0a6d217d0593005e41907cb117382e648f17f7fe0843b1de91ea265263b1132099e93aef39fdffb496543ea857", + "tags": [ + [ + "p", + "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + }, + { + "event": { + "content": "AtsT5C/FsnbDF4mxBTUhIuGB5YVSbbvutZTOe/pVmdNU4sfzb5nX0aCj/lbQa5Ivjsxi9sAEEPDQpifkeB2qxE74bAzPaxqusYWc1D34jnuIh0bKm4aerrcXF1Pwaj55HwTgkRexAnbA/O5lI6hPfwYgDrGb0GdyIKaOoeNPwywTA/M3iEAFtnxAMr6jnS8Dk1xBUZYXVBih3S7SMDuS4enC0emGG1LcSs/xcvzasfyGkK54mL41TZM8ObArmvTl2IDA", + "created_at": 1791465433, + "id": "6334e6197da3a9cccf2ebb566d8869be22a02d9bcb5df2cf114bfa1ac491aaae", + "kind": 24242, + "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "sig": "99db0a5e51bd14a4ac7213067ae1fde16850004859f9f4bedf49f644745a27b6c8f9bd9f3d48f3b15acc0bd36a44b266115e310ec886c2d7c970b3898f30a880", + "tags": [ + [ + "p", + "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"71c69a4b8a6bf0a41e2b862f1c6923b548ad026473f03bc204aec9b841e3f410\",\"timestamp\":1791465434}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "730dd3b666c8ae9861d43b4f466486879373c9e8434ae346724d954d64370640", + "payload": "AnMN07ZmyK6YYdQ7T0ZkhoeTc8noQ0rjRnJNlU1kNwZAw7zkZMoKiRiTK93xqAeb7QDuDRcK5IYd/AsEYFpNVlGfcfeqKXiDAyWOwrWTqGooD16E6AZAxMYjo7me9KJbhaoj" + }, + { + "length": 16, + "nonce": "556a283834de1c0f4a570705f349c063225841ba4db5ff808f39e0b8644664c8", + "payload": "AlVqKDg03hwPSlcHBfNJwGMiWEG6TbX/gI854LhkRmTImOzJrym/EP+UcmofbunEs1JOCmsr6i3OozUx/l2HvYHbJfWC1mukwGn290W+Gj+aC7TuOItD57LqE0c6NQ23qkBG" + }, + { + "length": 31, + "nonce": "b5f284fe48ba8a0a95bf23b4f485a14602367a18735978e396f9480c066489be", + "payload": "ArXyhP5IuooKlb8jtPSFoUYCNnoYc1l445b5SAwGZIm+cVf9lU8sHM3Kk7ipHeuHckheRSPGxcNFuOUEXU+I0TyeFfJO3SJhTmUA1DyzwhjUvnj3hTeHrij6YFrUxsRChm6Z" + }, + { + "length": 32, + "nonce": "c8bddaa582eece36e64e0b80799bd6df095f3b1d42aa275d787fb718cd15f985", + "payload": "Asi92qWC7s425k4LgHmb1t8JXzsdQqonXXh/txjNFfmF+Le4EEkSwZOJxO5fy041XroNZ7TIZj/VuaOo7Bx9QJwVqVx7o4hFyCPrsYKeZYB4ViufddRUO3hcBGputAGUjBfG" + }, + { + "length": 33, + "nonce": "993bcd6fd5457832884c0a4ac16538ebdba618c0403b4b49a1443571fea23027", + "payload": "Apk7zW/VRXgyiEwKSsFlOOvbphjAQDtLSaFENXH+ojAnxW6FhBUqjv9PiY44ML12VBfiTpuuCt7NjOUQXlcXE4lPPGMW9RulF9/xSrjazI/bywMViIBRR3gjCkW7VEVeJ2sGR20Gs1Rn4eWTo0Qp8MiiO8v83wI+YPe5DRtvRIzn9Rc=" + }, + { + "length": 64, + "nonce": "a386047bde1ee137f258e3957a38540788805564a7b594514ae826e618d4321f", + "payload": "AqOGBHveHuE38ljjlXo4VAeIgFVkp7WUUUroJuYY1DIf1IAYsoncsx2K1z0fBkZzn/8UPuMNEo1NN6nfXbROS/e8DQO1OU/S8hVk85iR/xNQ4z2FmcSotTYPmOhyrU/aF3d+IiaEnQ6fZXC8Rg7hnNi7+UkkoNuc+IDYLTkB3LvcNec=" + }, + { + "length": 65, + "nonce": "da1b84a35ef0e40c6561bd9024aa3a6ed6712126de12d1482169a2781c44fcad", + "payload": "AtobhKNe8OQMZWG9kCSqOm7WcSEm3hLRSCFpongcRPytoXihP/7pA2jVA3pVeHZLwiNRlIniTR/atUOrglUSOYtvdwmyi7zcqntdqjcnsTSvxDaBCEEp3ueJ1aWwyOAkseyP+97oGPdSXoDtTMTMwbvxlqp0Fz8DSWJKyIV3qY8tvGQbt/fTtLOhGG0D2srB66ZQB1lF3R5oAUfK/pBQtzyfMw==" + }, + { + "length": 255, + "nonce": "a0403f0ed608ae7311dc8ba0517e20f787443f0f611c740c00208bb68c88b387", + "payload": "AqBAPw7WCK5zEdyLoFF+IPeHRD8PYRx0DAAgi7aMiLOHN8ixz4ZltxNauVZbTydkU1azCUbfCIRx09zya16YvzDnI1KsuXz4Z6McmeLF/eUH+Sg/D4lwad8i/M/hbD0pxFH4E5i/sF3Br9Kjrx+xiJD85LdY7jZOh77jl5gnKwAu0YgXZnaKjVo6EDeTxxayV+LdR4frlAJvGRVd3eZQsGKxowI9bdhYTaLWFM359yNbtYGdoBwHJwOsPR2Q3XT13d9kCGVcnUw/YfzSYYVHP3Fvd00hV+kW9JfFrACGm7CuxYVm1Mv3sz7d0EEgUu3cGZ8CxW2YBT9bvrcwBjfEYUKCSgI5i7QHS4byTrWzl8cTw0q/M9onql/T9khO2FWDmrOeUtOZSOCvOAWS5YyqAYzwxhjoZRb7QLBz+bNvoR+a7zU=" + }, + { + "length": 256, + "nonce": "935054aebf3273e871dde091e67de813980e584021594516f2997877cf65a8d5", + "payload": "ApNQVK6/MnPocd3gkeZ96BOYDlhAIVlFFvKZeHfPZajVZtlR6lQupwVn9l/9BkxcXBYUsFq/U49MMu7N2CGcv08/9IsM14E/FZQ+n6WMdo+mdwXmucHGyGP32xZYgtdt7lej3HyalxjBh/vrOYdGslhQEAOdslBOSCQXBP9u+ZLvh7wpkfmEXTrQY/vISFRRzoC8uYyQPCDVK07fwwcTqntNKCdLWPU5LZDnx9zKdzVOzfnBc5gtsJEXxCVPQR+e8HRTHM9SXh0l5EQfStkcH52LJrwKXoHst2gXlXFB01QnCJyk8vL5IK2kueNmarrQMQlmdJ9sLCosWIXcr3QJ6kuL+dulyBIrKBhza9eGnx2eZIevh7elriwgDiqoq4yJNTDSQrrOtf1JjOlX6pgTjUBPXmm9zZHRrKj7dPbSNCG36MM=" + }, + { + "length": 257, + "nonce": "76b739a3fcb1a02e2052587c0708bf4d50c56a89cbf850e02cd892a21cf409c7", + "payload": "Ana3OaP8saAuIFJYfAcIv01QxWqJy/hQ4CzYkqIc9AnHzmAu1aw1bZ807W/TBPVwmOGigt5AKeEmjvURujpKvLUglmas6A+Lg+wS2VW/TCQdFmUFNwd8sxxzkPrMaQ0UVASwU4UZxpxNRvgsPgL2kLuD0WCV9GAsTtz0tbnCvu5etZZjJmOH3suHXGwLnLcWTCwa7F4t6u0YI4TAj6hQ0TDKqWXFmTt6Ba+ggTbVtUNCkwV++8+UGiuNwVghLT5OecZ5ge+/DUa0WIMGrP5JeT+JHzUyKf6BcOx3y8L0EKdQHunQ20xyeEOea2G3raPTDVeiYHn1FoljS90eHOguwgVfSn2HoVwV4gajecWnRykr5MQfZo9TI4/3uBIHCoj7JNPi0ZFjswRXuVhWxNZ+D/aKH6pBHWB4Br/c9APi6O7mq1QL/KactoJqL+0GyPZeTLRZsZOc15ws26l1XFUgT6NgN9U7oH54r30hJvrQDv5LwaSCdMYSI4tPL5JyM+zNx5uP" + }, + { + "length": 300, + "nonce": "61856bbf0d107107402beef928a1a615b4584a42b40be3b8ddd46fcd1a1f63f6", + "payload": "AmGFa78NEHEHQCvu+SihphW0WEpCtAvjuN3Ub80aH2P2n1/6OIR/XzjrA4TZdQP42Z5ghDDGuCxmpPTDf43KbFfbdF7TenDFnYed8aaV7Srts8OWJPOTLG4e3M7JDv03qiFLf7OnjtDQOy4HhQMyr/EM7oT671qIi/nvyL2qSwLRoDTWDD4pzWRP4Oq1XB+YLXkqxuWh8XhMQwRGRQ/LLng0HAFL03e29xlWwEDS2vv/+YdEwGOWYKbamUgWMzUIwfeAJzQ/7PoDrMvFS/GUUQHvzf4MxVhDoKMTH/0Z242s3F/YFABmIpRiM+Qxizl2KB9dqdgaqmxhfFeuAPf5gM9dmbreRTFSiTB5pcS7Rvbk4R11bD+o5v2BcumjYAihcVqKKo/0cEXeoDGIvD95NSOf0gNpwAePff6b1Fvt5bTZQiq0bM1TTGHjaifUb7JDI3WTzfwogQgInTZxsN/4TbFoM1xokjXWh8fHWtep6v0hXEUFbjh/Hql6FN1RdAYDq+rU" + }, + { + "length": 1000, + "nonce": "440f1052d4aa459143ebefab3ac9f1862b83b43b2a30e9c5fe118a274b1dbf40", + "payload": "AkQPEFLUqkWRQ+vvqzrJ8YYrg7Q7KjDpxf4RiidLHb9Av9dLQBFluG7QoPhLVbpUdjn6e2SMYGbOSek0TzAKmjvPM7QDTpKUevHFzCyjqB+HnetQKEm+sIkMPoJSyq+YsAfv1Mr/4e8+NC9vfq6fGXPfCRqR9tCEJQOqBz4gRHeoQQbfpvYdJQdBxsxb3QQtfF9LqbbRxz3j4SWg5nUU6FN1sdJHrWmUCuhwftAbiXHmaVeCPPMNkeghIzU6WzLV2MssFDCrCKHaWLP0vT33oPe7oBjs0eYCR4iyCdgclXr47H34dPFyVfj0w9zYMLYreqXy+zsRHFubWvgOsJoqzif7dht6U5Gpau1CwEYt0bI/e+bGgzuPtjP3UdawtTF6HPPx5BeEFL0/N0WyXY28X87Q5hWZDg7jD6+Rgdm4KSWW6s3GxrCwvL5i3VeTCkB0E6LUpPcUhEC43meuDJ0lpdPg2klvduQUHOZXvbK7BAUF7nF5VudINJnulJvw/SKYgvdQY87Q0qz2SqMAE7uhfjR4vM5Uknl0pDyqRdTyOgka7fuuFEa2uNGGzgi71DtNr9LmKi9o5fk4ZTMiMardnL+movlx2eln7RidxN8DT4AHLORn4NyrjdBqXoOtTzAh666AGudbjpVWeEeQ3G1rUas5qjYGsYAJHFeApiUCI61bbVi/NWlTL9VET2VPNxPVhkOf+qBPsgswfYg7wwW7m8RpE/EdGDacoMtrgIQnWRT/ptYX4U48l559CWYXkL/oOK3eIFb1DnnGJzy/7j58iLDaDJ3JpjN0LmapW40SfkI0RXWjsEZYwQKf9yVLbv+4fixhx8UKBEIYvHTZBNEABp82d9kSICFsxZ/1Zq7uT76w3mrM7DpXMgIVn9dTwYpX/3Lp3j2udIesqgoAfo6WIxWLfSBBWqdOpVzLk45xR3NFOPhcGQELY0m+VWtafvNopbTpYxsIoSVp46y2JjZUWjC3u3zUYxYJ7ZWfptViWghQTUV6Co8uGIDEmp6nk/aLC33C5YjvmOZZWHFuv8ZT1eRXKxcECcqE4HQa1Fl2VfBQIIcDJK1eMQTRXCPWzZxU3UEFabKe8eQ8K7iasGCNxojmHOeUCGbpJu8n6xME077430TvKh2o9Cvq+HMFQgqxJaQ6ViS/lzr8vugivwE3bTP51tw2aSKWyeiEkmCQbVS/nik+SG7WtxlhXVselxFUWjVuAmc9e7xXE3vY/u7RIe0ERIIHWxza6aclglq9qi3hNjypSkAPrM++CbvDRNExj+LtvLKH/ihUD6lnZ6yjcfnCpEA5HwRe8pD8HN6gkD0pbcdHgPPpodkl1E8pfNfnCOZ5sftWdg+BvukBcxXEMEWKqcQ9scfEhaQxvQzP6m0sdo5GsPUgHiXVIoMo+OSeOwucdzmQYDOZlYzFny/hD6SYfyU0bmDsduJ6Cy8fDwk1dUg=" + }, + { + "length": 4096, + "nonce": "66a33423de475bedf128ebec41029ea29445fa5d52d0d834286c220a09dc891b", + "payload_sha256": "d9807da1669f746436e309df8912a9a245832d41447099a1d10250fd272edbc5" + }, + { + "length": 16385, + "nonce": "bd61789fb7f0238be2ea43d7f96aefa11304a985d41b12b9c5b600316f6f78f3", + "payload_sha256": "4e4d871bb57267782a5c182f2b54f30d6475b6ebe38510cde6c1a2bb259de223" + }, + { + "length": 65408, + "nonce": "763362642e9d032d784b56997603b630b884209afa1deb539b2863f1c4d62167", + "payload_sha256": "5f1660508a52ae07f82ba1b8f6b0d2fa95fa6439e766ac6f4b725cd618a71408" + } + ], + "peer_pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "peer_secret": "9564324958c336ced3cbb1d8892a8fc5d89604473194e457a2fb400456e6a7b4", + "proofs": [ + { + "proof": "922573ffe9f4b5b110eaf9be75c8ce48e86d1641bf99bf4848e863a1fadb0cb0ea0d33aa92725d8e3788eae9369a5c959e85d211be1ceb0935a1d022fc0831fb", + "timestamp": 0 + }, + { + "proof": "ea402e1d0096ad123a385e2f2059e6878084c6a2449c918f60393c884a3649ec2602b6b2df12426c852f1128360f1c42c74b819a8aa3a3907f7e587424297de2", + "timestamp": 1700000000 + }, + { + "proof": "7b4e699cddafc80a40e39b11f518152e6918d0c811b3b0e3f0f2533fdafe0194c0c695dfb8b032a8c0ff645ea80d2d2d902c598fa178153879eb10939cf429ae", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":4,\"verifying_share\":\"037887eeb910932a9c7973446335c1fabdb1911b0e833dd7abf944ba84f461724b\",\"proof_signature\":\"fea8949cc32d62a1567b4e4f921e9b01e1a91bb72ba4d2965d6098d94ffc36b29d9e6a49480b1a583ddd98b92658441ca509bd4bfc9eca66791c4b169bea2307\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791465432, + "id": "49846311340fe83557a2b5c92ff1a0d223c13387debc1aadcd9e51696a2f3326", + "kind": 24242, + "pubkey": "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a", + "sig": "dc862b44488d38c8ab1afe6f913532e4985beeeb1b58886ac713028309a15974643e49c4b0ef86bdbee2cd5e26484d2f3b2ededca8ea48304b99e0a0ec70cae7", + "tags": [ + [ + "g", + "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + ], + [ + "t", + "announce" + ], + [ + "p", + "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + ], + [ + "p", + "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + ], + [ + "p", + "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + ], + [ + "p", + "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + ] + ] + }, + "events": [ + { + "event": { + "content": "AmF1aXAH+eF56+FkxtjldHGX/OVkWGp8cdiIaSxi8MHoBA42sas2EulzOKR8n3xCiIgF+YLLSjB3SkKCK8QqbnY2uWHsjyvcOL93eki8kaFyXZ1T48uvwmfTKEdq3Nj//9HepTPO4joxlleHStmg6SFPaA5pqxXqpDlIWrH3MTPLDhUVpV9QZ+ezIGdbPKMZOYX63zjFFvakGaFfHVsYiRYlYGqD7HZWn4hcDCLXJuCv2iYVDRxDfPoTP6GVetVYT6Ie", + "created_at": 1791465433, + "id": "2070bc15119699341948f659b4ed20246a3c17f7edbd528391624433f1a8d135", + "kind": 24242, + "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "sig": "9c9505b072b7d7b86381f5e096b5a0dd78444cef0ec66ed68cac4c8e93511de140e0c31d41d051714147ec398ed7c242c71d26e327bf9770f2ab284a4d8c3f8e", + "tags": [ + [ + "p", + "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + }, + { + "event": { + "content": "Aii5LtRgH98VsZ9WbxwBkUr7g9mwW0nKoB0MRs4+xNtYHDVdyRnFJEOUF7bo4D873HcZVC5v/hs6nS3bLKun1154du3lS6sKgimMNt22NKjCY40GkRD7Quj+fIVPNpKVyXw3SFF2tkkdFR16SKahsPh5Iq4ypeELxAGNkl00QZqItjHzT6JGe7bu1OXiLL93j9PlLa/lFHFcUsM4h2p05wH9RhmZQtdbpfEtPoUI2TP6CjJV/0akVPhnMku8tpiXqfDp", + "created_at": 1791465431, + "id": "459e5fbc8399514787c98647c5a510f527580de63a6161039f14823601164bff", + "kind": 24242, + "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "sig": "de3fa141e7802cdbf05b939df834abe6bd15eb9282a0a74b88f320d63cb7f672c58b77c971a69f4b17c822a31bf1ad996eb0e5e4701fd5f19a277e735014cc32", + "tags": [ + [ + "p", + "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"35ceda61da1f2dc866008332a61097b8c704ad1c003d74b17f37a2185c4c778f\",\"timestamp\":1791465434}" + } + ], + "index": 4, + "nip44": [ + { + "length": 1, + "nonce": "1c69977ff38e31e388fba8e69046a7b65691c1c5461d23d7733217d758b0897c", + "payload": "Ahxpl3/zjjHjiPuo5pBGp7ZWkcHFRh0j13MyF9dYsIl87BU5jSha7upoJCY4m+4iMBo5QsdZkO8VWkMJ0UBqcQW7jKAxDsrUobwzRAlzGa1vQm3fykse4lVjVUrzFn7+9rU8" + }, + { + "length": 16, + "nonce": "5564d89263b681bb64b6a5ecb9b798b92c413444a406ed48da5de826663210c3", + "payload": "AlVk2JJjtoG7ZLal7Lm3mLksQTREpAbtSNpd6CZmMhDD7DYpbB4Z0+4qLR+WOJ2f9eQW7uBvnX0PxyaPEXHztXhQumliN4KadTw4p1oha4xYbiKSqhlRYASVoLxpdGV5PK20" + }, + { + "length": 31, + "nonce": "3e0b0ee5b9577179290dcc79dd5abcbf2d6aa6f8b02d5cc5aa5724b48fb9962c", + "payload": "Aj4LDuW5V3F5KQ3Med1avL8taqb4sC1cxapXJLSPuZYsKonUibnHTyLed1igZRWSXmq+jMhK0g4Tjv+lGtSNUQtGZe9tjUTAtTndiRzUODd0m0boeOg0jRLKpkUw6fc0S2K7" + }, + { + "length": 32, + "nonce": "09d116af03e0a744e2df6cb2680546508d1242eb23de986df97c9c53e7a49e7f", + "payload": "AgnRFq8D4KdE4t9ssmgFRlCNEkLrI96Ybfl8nFPnpJ5/HJFJc1gLv4CgOomLLm2JKFd4GSIdUqSDEZUPLd3TgfViZF7m+2CWKh4co6TCVo9NMtVA28Y9D3V7883BMibwt25X" + }, + { + "length": 33, + "nonce": "91bf679d486db1a134bc0610bf5832e87773858ab80bbf87a63341321961e56f", + "payload": "ApG/Z51IbbGhNLwGEL9YMuh3c4WKuAu/h6YzQTIZYeVvFRy9ZN+fcheY5JffetKpNzkF0faK+50ghHPnOshU9MczEnpfb/IIbaTM4zIGkrtFWVqPVQHd7JqJ+xnXhBVpXVN8ZTKiGW4bsKk9o3F4j5d+F73nDo+bAanGFJZag0SRtIY=" + }, + { + "length": 64, + "nonce": "52e3346af81d9e4c18765ae23c11cb017fe02a6e9f51d5dc9f21211ef7731aae", + "payload": "AlLjNGr4HZ5MGHZa4jwRywF/4Cpun1HV3J8hIR73cxqulNfcl1f1O26LpC+G0AY3+pfNfLrHlkiVJlqX9NpllRDGYIUgpspXNikNAzi4Phj3w7RKz0dOWgowlnrkqnaYa7+hpfmvEwgUvKOm8uXN7/BMzri0POyUv7RoT0DCg+lmaC4=" + }, + { + "length": 65, + "nonce": "4243702f2b82f5a460b2c73737d0452cf3d040097bc4af6a53a7474e0c3cf7e8", + "payload": "AkJDcC8rgvWkYLLHNzfQRSzz0EAJe8SvalOnR04MPPfoIHIdKP3KUNnc450J96gCsj+6kV5D3RQAgHl6a8Zg3a4MYpWH6cp1Wp8mxXCP99JrxP8HbOhwf1jfhzrhPgFxt8V3CcnLKeomiRLG8iyc82c8NXsuulE66ZaJSd3gk2QvE95lr4T0rtuTIyLW3KKIwtEqyWq+6rVHojbzGx7sQ08QhQ==" + }, + { + "length": 255, + "nonce": "276eaf1baf6f4b911a4e857d04fe411859a6518d6d5e86011f095426458cde52", + "payload": "Aidurxuvb0uRGk6FfQT+QRhZplGNbV6GAR8JVCZFjN5SxSZZh9KLC1ky3zvpeX5KIvT2DEfZxGI+uHTqXtAXEHmqPgzB0/fAhDEVN2VJpic+HHsr8YETikigfvf80qp6nUfI/voF9+AS6sozD6Q6au0r1cptf0zaodPBFDH8aibFwlAJIo4pXVa3MhfPithcEtfTfZutRGZj8j+TWzTUBvCQ0jfLbKDMoM2mitNJ3B2pxIrsWqxsz98OUXyrpGlYaVdpzps36ZfNGqSyQMSUL+jibVVlHU7sLRV8TrgkzQjYlioQ4T88p1cwl2XQuRmPZxGK+uZwUPjC8x6XP1Hd28G1Mqj7SG0gxUurHUwO4L9RxomeocCxw+exZBsEheraTkCdVMSDq/kNdCtbWDZBSH7qL5f7JRuioyxtFiV3aodow4k=" + }, + { + "length": 256, + "nonce": "da9ef386af6f248191670a3587581c0dd45fe1708b38ae866873c1bf3be336ab", + "payload": "Atqe84avbySBkWcKNYdYHA3UX+Fwiziuhmhzwb874zarwoes+px6I4pF8sPw3NpPxk9Wl/e2i2EKKC/sArCjjIqzd236n6TPrH3DdHWF1sapQv/PHvOWgCgnMIrePKBDl9aeucMnF4vyB9fqmJi7cPpe5mw3ssdtd4jXeEERlKO84yDWMjsE7mvRmfENP9M+Y9uSLTdefdzT+8e4IwZZSUlN+J94ejTsDP5h4ZoedAT37MQqbyBlcQDXzP1Tdee/cnLMN2FNTwRxXG5bpD34nraVdYVmZzjFfhzsZzfJsa+x2Nga2fkcRKxE1veVSVTntGOmF68bZxh7UytSjBhoEwwQUGQY5B8FJzfL3Z2w0qdpmYhlGHTO6vpvvfSWjerosKx/BJ5oYdzwpVWSRVpLIVI3esBs8+GydNWnqfcIDY7DEUY=" + }, + { + "length": 257, + "nonce": "3e3cebd5a65bfea511d4f74daf272e34d2c90d1592d0fe762db7b84c1c2a891d", + "payload": "Aj4869WmW/6lEdT3Ta8nLjTSyQ0VktD+di23uEwcKokdC/BhkeAbpCMI1/8YlWCWJyJFXZtykwKvnYm+06OHGRvh1M/OcwOdqsVFietJzsPuwOxmpE6wAGn32E5S/2nibTjhMRohZo7Ml8WbyIy9HQRr6q7faIvCRe8OPvGYlxAkLa7oIq7yJJrr5ExAP0dtdkCLKzmwNchlSD1m/1L849HtFNPUKOeRbKGmToTKBQ1HCZPgPKzJuU5p95TVozUeY7IzyFxPhJE8BgZJapGeX45bkpieXDqnqluf0NJgvhH2fxbk9csnnQlT99Bg4QpO2nlwOkiwryamGhyfHi3S8Uh446ylLZrBJHKjbriVxHx6MGYEXo3b/NMdguXI373Or2SW4ePPmO+hcuvsw1BryIcdo+brJLChychmuKjFZB44mu9f17ZfEDo2caYgVn+cxGB1x1P8GBPsSzsGHIUDI2Z1MxXazJLq3ateyazjnvw/aaDo0uXBTZ5os6QazEgnxJDv" + }, + { + "length": 300, + "nonce": "40ff8c18d0f652b4df34d16b6dbdaba5508f6a9b8e50fbd79fc8290249a6361f", + "payload": "AkD/jBjQ9lK03zTRa229q6VQj2qbjlD715/IKQJJpjYfBlTkeJwH/ImCKf8SoxXRrqeyG8lIUO3jm6szDP98fQoz/jY4D3tsAwTH72/WgjteI1ONPHrX2X4h/WK+x7rv4seF7AsbjP3ZZvWpK1kjuoNO8hKjeDp2Kj+Xy6X8qYOT29rzzAS729CIhgHE+YYs4UZF9DV6xfpW87EQkmfFGOD5TuQnE4h742cKmZEJ3MChTEZ0Ht76dI4zjSEElBNqcyLgfSjN+L2w8q/2h6GNt8FptQcql1hnIhnatZo2DA0EA8CQYEn31pR6D99e549Us4GnuvpdMkvySMuKfLw8mFyFMW7VB3s0qCDHlwBk6W8SIm79UgpflKKmxtb5BwacoO/yokOd01OhAKSuu5vQeGmIa87kD8TDvWvPprbr1Zw9hwkBrdzPyvIERGreuqyLRD2I2An+fTP4dD7ORzc2LnxgygJdjBw1+XXpVz2WoOJxhK7CBFow80yJNlsbMD8nI83Y" + }, + { + "length": 1000, + "nonce": "0e2344313f168f53586fb4198a97093a4ff43ee06386ffcecda1cfd06c1293b9", + "payload": "Ag4jRDE/Fo9TWG+0GYqXCTpP9D7gY4b/zs2hz9BsEpO5KdUntu0cXNJD/sPGbJjH/bMKpDww0PxihBm7CMHWPZpnnh3zX2Ptu3QNwQF3qhgBkNTu2+IXbV2jQausAUthLBzLO+zAP7hZ7MRfjFUlf6oKRe9jlkQ9mMm9k8BAie+48tq0wbSYyXTBIyuDhi5I1/mMzjI109ywksRVxA1iW+1+5F6niyp7ZM3mkAyBnGaIWNBD2AhtBrlGDTtXHCeIgMGWvRHgcqf1bCJQrMgZq0OROefELBqqq4IisTQG4KyVBhemZDuaFhPYpeVhONcI+DyRf28YGmEIC0AAvISXCAwhlEg/Nk0mu3snNpcK2XaKKSx+JqVOTI+3RR7wemiM+4rhGpWIaOr82+deO/+zEfPa56z2JSvyzWCjxFb3zuayzuKRTKszvl6yU9+Bj1JKVAwhB5hWrHbNxHXxeSa97ImG47lFw8Y6yrszqJIe+a3j63LpnVlZnBBYtVZlWvrB4aSyI6LTf+EA2GnI8jF0vPGqDQY67qPgj9wjVVZ+ya33XzpLfHRplgAjLHQPalAo9/2CuiutKGdalcSwPoISKaTOrnsLckkyPJIsAzaMA2ozXMCExTlvZrg+u0fuQoYvwOLk936PzI/HNFoeqQdwOuNxgbhGUTn9db7vxlkk8R6yjHauJR0gxaVgRbRucfVDcqlKN4iozBthlUeKTn/lgm3avQ/OBiH/WElkICjWYKPUc5fb9MnjmiwhWo2eH/hzwSR7uaCS81JaLTAPrExy4tE5xgU523mxUvl2CTvcPgb7hDfVzWKOXWh8Hd/mvLsKFq+yj8DA6sB2eXvktCYuWywhOC/SWjwmrBoq1rgDYxzzZnmgQ6QzWQvE2XkfKZWZIiq+r2xndbfTnrjcG2LNxdkCd0s3+x528opwoIvxC/lO/UBpPFPFBce8yJhqRGxxWVoy4rS1Q4asMJQKYrw1yzKY2AUC/hT2RwPd4bPFfygaQIL0wnwIU9wMwlVKKlkaV0SHmCJcXiPANlhtxmu0OoUk0e5OfPn1RGBM4Dkse8JAvdoaguEVtasDPJ1Sg/lZ4lNnGANZ8toIyHKLpDFRoYQ0DsVcmVkI7A1XbmCvXd8/E50grov0cWxJECUNjQIOKkh7SkNgefodrNy/ecRqw+WTO5EHImLnWzq9G4mUeikyGztGdYRNgFlpIDgIWNBxjFq0nReb1LNnYtJIqpiJ9VQnt6XMTgv9HUdDsVuioeqr8DwZZjcgcPNsHzzj58KA/dfAekV7PN6d0qGukJie3gPIOJWx84ODG557VrYKFE42RRfF5H/uP1BgH3dyvLwKCyfg81QsEkCwi9kHomT2HdQ2qqkgxnU9pde4UuhUObrE8tZraO/HxNGOwO0jZV5GpOqqxYoqzg3+nVuttkfbbUgG19JwFnOMw1GoYJk1qYVj7go=" + }, + { + "length": 4096, + "nonce": "5ba452ecc994c974cd71245debc1c5a9bb6d8c7141a87ab1d7244fa8c6d0ca88", + "payload_sha256": "952308e3aa383c613c0df2842e3fd579b0a32aaece24a3728911bbca22a74e1d" + }, + { + "length": 16385, + "nonce": "09262a342ed3e1b304aea5a803ed4d27fb5c383ed31323b218348d759f263809", + "payload_sha256": "137397dd86100782052af73b72ce18a7cfcca12afb7913734ce99acd6da61658" + }, + { + "length": 65408, + "nonce": "336a3fde9e6354b33ff14db56f59c5357fac6e96374f7656afc1822f3ed786c4", + "payload_sha256": "941c25bb022da7e398edb80cbd213f00b8506c90a54d0cf87e4c87f865fad73e" + } + ], + "peer_pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "peer_secret": "2875faf11d95de0042df207ea55ae62a67664010a3f8b406b1b548028d5d574e", + "proofs": [ + { + "proof": "937c4c0f6ca0934ea0ff562939693d016f2ca24a8a667dcef3adfbe7b4abbb23b567886bef0342fec6d60b9909681fd6cf5526b4e499a4d4349057efd3998424", + "timestamp": 0 + }, + { + "proof": "8678c8762e78c7d54d479ead73beea5d69b80a683b86e0f910d6ef9ba766b5b542448a1167d6c6221a0775092cd1f6f347953c6e00bd96a62ab170bc1e411651", + "timestamp": 1700000000 + }, + { + "proof": "e9932154c0fce45c9fb258cf6b1d17ffcb082238736afaabfcc8ab9074496c97db08c9de94d18bfa534004f236047a1d85bbc7f8001216adcc6d84fd8a1375cb", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + }, + { + "announce": { + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":5,\"verifying_share\":\"020f00ab70660c72cb08df914e45202c59819af901044bb30d882b969a1ca325a4\",\"proof_signature\":\"d5eae859ea5cc22715c59080a2aa8b493652b5f917e64dd64f03da615caf9dd9e971b992843475b83749581a8256794715f12040dfb7caadf6863b7d5ce6f91c\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791465431, + "id": "6d25ef8c7882362c6bf94cdb60dbc8352b0e6d4eb1b7d29b1cb63fa9b9c9e1d2", + "kind": 24242, + "pubkey": "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f", + "sig": "5dd778f39c78326d3464beacae7e5c4d0fc72494481368e2969b1ff2dde440b8765212a51f04d8f5c75e15e9619f59047ac42b02abb5672499dd85a5d7db8be1", + "tags": [ + [ + "g", + "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + ], + [ + "t", + "announce" + ], + [ + "p", + "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + ], + [ + "p", + "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + ], + [ + "p", + "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + ], + [ + "p", + "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + ] + ] + }, + "events": [ + { + "event": { + "content": "Ar/vFPUjMyrTA8kdq9eXHOx3C3e5p5Mo9IJIO1SJmqgGSJHx13bchaLrChTTq57hib1fANN5gnO+3dJCUIgD7HJflmQpK9lt4ZFPJcegCUMg6wZ43rmIE5bd88Oxu8U0ugb+PeyCdz+yGhE6eHnue/+1xWJQ2xAa9R2xGEj43s1BnJspfNzZjIPpF7GRr35o/Gyz2JP4Q0WUCZ4BnnIqsd2qP7GqNXMe/dlfDbxom1VtsgwIMh/sCkZbk16Af/o6aoVR", + "created_at": 1791465434, + "id": "5eeb1c469f7373c951015d8c1252ae0100113c6ee2cd114da9777804dc85f4ef", + "kind": 24242, + "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "sig": "37ef18555e3ee36980e80d139666283308adbc683e5512fe5447699f9e99dee81b10218645570510bb0c48897ceb296dd7cca5ec5d57b9cbde3022de6de3e75f", + "tags": [ + [ + "p", + "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + }, + { + "event": { + "content": "AruFgbQo6N3kIESe3YWR7UEDDDdqeZk0nyrtsW/X5uhG79DaE+e0NNtVDPQtSAlSku8fGFIu64QHFnIpZzP6dapcrWOx3AIYuIE7IY5yaNAdaXyBorYw42HgKUNeCsMscynPu/O2rcMBJGkk2MuYy1zUCH6fRW7osG6X54lsZ2a5RgKZxGe6EU9SPNXWuAqz0wQho6fgEoAOwouYAvsR48KUUCwLMVKLH9xB4CkqHTRSCC5GpEFbW4JMRoS8xnyQgkJL", + "created_at": 1791465432, + "id": "6d213f80da9dcff6e16fe295ce8e0f124a7b51e57c1c713a1f4ce7fd19ce8d27", + "kind": 24242, + "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "sig": "e1ec74d64ad8b0c3b99c5d39463352439132e33ce18f04cd97a6310621a566e744cd4de8e95e45908502f6d2a80a8fb760775a3e05d752574413bef09aefca27", + "tags": [ + [ + "p", + "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"c43ba0789f984f694c603c1e06c46420f5aa892f491c14230ff4293c07bc8259\",\"timestamp\":1791465434}" + } + ], + "index": 5, + "nip44": [ + { + "length": 1, + "nonce": "3c7ac117cc2377f234f529e9cd6ef74fab4743020ef5c03422382f234677a660", + "payload": "Ajx6wRfMI3fyNPUp6c1u90+rR0MCDvXANCI4LyNGd6ZgM8rcljYTIfeqfWGgfMVZ7b33qvD24pvpnat0U3UfFN4WyMExlUqpdUoEyQOthMO76+t08g3JKlAfBLoJpdsuSHOm" + }, + { + "length": 16, + "nonce": "ecb19febaae9cc3585efabbef1fa716420cd1f454d0dfa8ab2820fcb7f447860", + "payload": "Auyxn+uq6cw1he+rvvH6cWQgzR9FTQ36irKCD8t/RHhgOj38APJOOnXMsz02Kq4q2/bNZHw9BvEDx+6+exOC0Irf3pIfc3+Jh7ezMvy/mkZoHhk4BevET9u67vNNBC8t2TEE" + }, + { + "length": 31, + "nonce": "a652aa09714288e2fcc7934abbb7fa2d4dff8c902757696c3962b299bcc2dbb9", + "payload": "AqZSqglxQoji/MeTSru3+i1N/4yQJ1dpbDlispm8wtu58CSWjvy/7vTP/ybWTFVWHhDjVDlVsd2FCnU2yo3CmHv09RH7SX/n2PoVKHGzMm+u4XioXIY6KzxHUwuwDWRlZO+B" + }, + { + "length": 32, + "nonce": "9b21df32e4cd885166a4300ea670dcab9246bfae9a21ef1191820d6a41ed3836", + "payload": "Apsh3zLkzYhRZqQwDqZw3KuSRr+umiHvEZGCDWpB7Tg24o7Gflt+aBZcrh4Ek9lk3Z4+IQ6vFjsfCEDTsgFbC/drVaOzWMqBBKdtdHsx25hWI5pNfgiAEeosysF8VMHEDBT/" + }, + { + "length": 33, + "nonce": "f2b8a78b996aaf89aac6ca058e928da7fb9bf74d41230c321cc49e577b036242", + "payload": "AvK4p4uZaq+JqsbKBY6Sjaf7m/dNQSMMMhzEnld7A2JCsYGX7lOiZs8GXs88K1EvR/2+lxULgz4wxWuxd3Gp/3y7F+I2ywOq5KEBQTH7vMmTDFG3+OM88KJxyrLrau4C9ARSGrfepIolmaoEgwN1XRbpMPLf2OAMwPuan7SsgQpRed8=" + }, + { + "length": 64, + "nonce": "67f6b822b700f7a8de753c33fec9a9d5f5fc726591909464ad200a87ea3ef9fa", + "payload": "Amf2uCK3APeo3nU8M/7JqdX1/HJlkZCUZK0gCofqPvn6oQ79EdZYXG0E0T3f1GwmjgcooiBl/0QuVqvQ4nNr0dqWBbKYUGuv2WWb8zPdFN+QIMCLpIolfZPoc8tX7l6PQJdtTLVMB3fxhhL2MkHwF9eQur3kE/dELzG8DY6vZrNRtAw=" + }, + { + "length": 65, + "nonce": "2ea8e9e38e9ff0dfc3e8f0ec568071d6fc78202ee9df257cbb3920f2e2f4e01c", + "payload": "Ai6o6eOOn/Dfw+jw7FaAcdb8eCAu6d8lfLs5IPLi9OAcOKIu4Z5EVNTsYly0xIw/IMnjk0w1E264S/jX3kEh3P5mp/Z4Cmhz+WZRLhV2bOktYS9ukYG7uaoYyePy2NOuz5ZX9KMtL7qK2x/3fxeoQ5RXF5v0ICUPOVWPC53K8VGw7qFdUwV4Cy9DpoH3InmQaYo7snvGHmJu110IaLyzJgiHAw==" + }, + { + "length": 255, + "nonce": "b36b8dc28587782b60f0ee4be993a630461f20ea9c516ddc45f1e68af9c8fd27", + "payload": "ArNrjcKFh3grYPDuS+mTpjBGHyDqnFFt3EXx5or5yP0nFcIzuRupTyznf9Ox/G3lRaXJcV5/bZi8AtJ2dmFUoCglcZPvBpvWjjAZo9jlN6rD75a3z5x7GuMoDzLK2s4QEYmo2k5Coi+gUvD4k8aAjF57rPnvu3acOdINXNbKCFMcPILMdbkh3KOfQsyHBE3lGWdGavojMUDaJURzXxQvJMzrMOoRzM7pPVc3q8BQ4O7WTkUNzyddGUj9hQlCuXN9yMlNWsUZZHtUMfLaXmzlVCaem+ZslGu8v9vOfQGTt4VKgmJjcKfNFN1V/CnhQGzGsPO6hdVy5vyEwRWsyCqSuu9MPY6W4H53IYyzUVS2dJ4XqQ8uMJAe2KJap2bzs4Jml9tG9vE/JMllJDHLsRoAcMzGdXrIXW1PoUMWu6Jk7fLR+0c=" + }, + { + "length": 256, + "nonce": "ae7b1f7757691ca191ab671262cda742cba38011c041584b99d8b460e4006e8a", + "payload": "Aq57H3dXaRyhkatnEmLNp0LLo4ARwEFYS5nYtGDkAG6KOOymPU3VIlM30EDqpIUqL7q9L4TL7btTv9o/G85zVxLkL7dACzIcz3v8frQJwJdqS+N9kW+AikH3PQVyT3biutUbsUuo8VM7mJ6Hjn95C7S+o/EleJ3PxhxZ0Egss8I98iRC1Sm8ybBnxoPf1XuCJSxfIbC5R3ENYUlPI9EMcxrlhLwqSeJRvytdY42PQs6X9LNTdq/Ys8qx9HF6t7Oz53g4NEmJjazZHdnmMsew87RrvTKYt+I2xot8MSe8HVo/mRqlX8lJQpMT5Ddg+8D5NW+oIHzCwogQMkqHFKsuyffGdCJusY2IH8ApiZNSPPKBZXbn2NAbFya327o95/7YvtPgdtZ/FhMwO2UIhSDCXHAIRytFvmHLT73XlGfaBGCY4HI=" + }, + { + "length": 257, + "nonce": "93a5444d50668e3593a287aa53f0f316ac08c48efeeece6b6a194e7a6101abff", + "payload": "ApOlRE1QZo41k6KHqlPw8xasCMSO/u7Oa2oZTnphAav/z+OvacjKe1KOUXBAI4Rg3Txts7c4ctZP3OOqOdKmJtGhQbcpF0fygV7DfqpLwn5HnKqhE6LKTnDcOfdWyVc8vqR341PNOW1CG3fEVSbl5SknWK5Ea0+tIiJS+vX3xT5LqAOBk+obTlIUQ+8ije4XzB0hlprDFbcD0MZoSMrZehDN2wY4DH7tzrwE40qIf4CJR7kopfSQ6ZVIfgu7uODoGSPO67b4ziqFXoPXMaFmutbvtHFkheie9+hbGD2FLmGnzZo0OnI+DGpYGJDSq/z8yOFlwVuN+DC+eGaXz0dcOnI6V0lSie1fd5Enplr+qDRF2BAFbnjXoq4Mvx2YX1g9WHC8a7UA4xe5eeBFK5FsW8WDOpl75wiwgOXYLf2IUF0V5bxigIv7SZFKrn4IUlHdPfwP54Ufl5b1U1NuB5yvBRQfUUFnk/+cT1tfwTNBpZyQuwUUdB7p9ZhdZ1oavhU1jAYp" + }, + { + "length": 300, + "nonce": "089ddffec7be570b01f5b9b2810f6eda4234454a9b5298602389f5ab0de19289", + "payload": "Agid3/7HvlcLAfW5soEPbtpCNEVKm1KYYCOJ9asN4ZKJfVUWKb9dak5OZtTNAUsCZuHvJM+yyaHpVCTqhC0edU/2t08c2oedclnEObTV5qoHeHH7O2BubDfJZIIBOiEIxgnACajlUHU7L31DvdXZWyAJr7QuOySpj0Djr5QJ1FBTY+1NT0qsPMiRJqYO5p4P7WsHD4RoT915vPm0DnVL3IksqDBYw4rlj03qIWfZbLEYlAO+vHF8nCeXBfOyJ22uKX1aLZyAb4zz+PQUJbYcorBEy7q44WUeQXfEwVE9jlrxGpiWCC6o+uPkyPRZHyoS20sZ0VvAPvgkYubHCUJvwJ79jcgKwhGtmV9gdSLuk0QvmXdaOnXzcSJ7Ct5RhcsGWabcuUfoyAUrc5G9hpnMtV40LnBUpIB+c9tvGMYEIMB53k0W1iHrFa0LhePDIfQmpl0w/B+ho1XLwEeVTyRovWHrb2xQNmTZQeKQqxCMnN6G0s/aCA/AI1gPbQpKmORqo66i" + }, + { + "length": 1000, + "nonce": "05628e5d74f4c5083b6e96aa9c29ce88fe3fd8f6efb4539454099c4e9a90b5ea", + "payload": "AgVijl109MUIO26Wqpwpzoj+P9j277RTlFQJnE6akLXqdxUnrD/gOfSFx6cNocWTqRiyA8eXAMzNtADfwVGfTY2HMaNGypY86pBqZDduw+6q3sdThRUT0seaSJkrVYmYLggVmYu7c4e6R25UkScnnlwVNJ6UeHb+mIke2F4LP1ypWigXMhBu06LlyNIzPmpdtNVxh8JvWg+PIxs/nNr70cBaMU2p4zBv3chtvBHnV0LG3kkA4KSwZ2xn99ylBld3k2TdMqM3ZKOoE3I7NaXWqVuEpotcAvcEDILdoCXB2zlHUnNLUME4lTn6vVjYf2Zhn66xo85XKeD0JJZgMYTkXz4pEJpUzwSbwz2WOpGEqVqcpC5TVZXSupmD0ofXKo2EF0eHYvzU8Yn0qcd66IZVI4zwbHRKF/vcPfi8aeTTgcolJ8ctAQFkbBFcrO6C32RoQf3Vkk/6181iXUb95zV1xHl+VXJw65vEwlLaKzAuzO2WIvKEI6gn4gH5QvDMpOoxScbeVl0eg35/KUkr7kDAyRe+LFv/HgGLmEHrnmTuvIXE06KrbjhALnqSZlDnP1SJdwirJPph7wZaz+nAljc2J0klUF0Gu5sCTB+5jBtwNdmc9HHwMdhU3193wAinlGFqEOzx4B4KrTG3M0JhUf9BKwo31rAju9tlWDf8d9119oSg9Ft5R8qypf0QU45aRBKcmok0pTwWhrdExPqS4K2iLcPhGNyc2X4oaGfrgq72gssIqOm8oS88WgALb39VifFkRanYXucTu+fG7ak4jBQVJIAroyfSKFqSqDVn2eGmSAWE4LbSZYnrr8iTW1jRqAUjp/SDTigJ8iFp7/B1Yk+su6WcL3AELAvHwbc/mvI1obLihXbKw+tvmJ7oAsNAdR8CWzOT15FYuRScQpRoq7DCXsrsnd1KqA3qRQYOWbXi2x1RHtp2uMcbWy4eKIfE17YSerfNoPyZMditBnx0nxlTS2tAOvYlT2ACDdc/jSaMm4Uk3Wqdbv9jaJ7bF7CpjJGa82KhKUFwW0L48DgAJCyrEQd9+8rXuTjyWvgLfYsv/2udAh3zzIVfLaTujsbQPeHV5+F5gMDyby5yIq0ruPZGmBn/Y/BQli2r1vLaWS8UaI+0pS1qOWdkXjMMCX1EZeK4pBWheZndnbgWsbKzwnmvvRPydn3QDUG5b9Yl8ADs7CDuMsCFNUnF4QC2uIHKtfkboquk5tIaXUHjxj6e9h5vcfchLChHKSVI9zwtke+Oqldoj2D30d5+Xza55mHhuFd+PXofUpW/Se09DxQ2YJjuHMR9y/fx3PD+9BBNmXtGbP207vEWEUvahXiP06s86g3lO7FHPDiP8cCW4zbfkLWypT+7VEV8lpuffLfuug6eDWhzIesXaCC2Qtcgh6a6iFRop50cbL3mFO0ZRSjDqshZLHFgg5LEgK679DOLZZDy7qEBLfk=" + }, + { + "length": 4096, + "nonce": "dbd98cc308d689fa14abf8fc129ef0d3699d3e327d570fbca415de67f480af1e", + "payload_sha256": "8363eee4d23b8e17e8911bf32fcca4ee860b5976fd70b38ede3c050832a96f26" + }, + { + "length": 16385, + "nonce": "a76a39705cf4744e4d07ff4bd8bb622bc1b9db21552d3416c47118ef1c74d2c0", + "payload_sha256": "70273468e08e9cb97b1ccf2aa4150726bc11bbade4de0aa51a2dd71bd54379bf" + }, + { + "length": 65408, + "nonce": "914a30009dc97047128a85142f1c56b96bc476b37d163f2ac11e1f7769a6684f", + "payload_sha256": "0183d8e98013085ff901e12019edf60fb343de5fae8b57acec41eadc2e7a514f" + } + ], + "peer_pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "peer_secret": "e0ba0a9c6583de51b416b8cfa5ecfb0810918f28bfdc3d1834f9c3862097c0e8", + "proofs": [ + { + "proof": "c2eff7c468258ae4eae0c2054100944b7b9247468d034ff168f51fc2093bf86e98c238146f23cd4276d7bd10811902703c9fcb339caecb0667a5a9ab30960680", + "timestamp": 0 + }, + { + "proof": "8f6a9d3602ee52c27918f8a5fec2e8734051a4c1bba83bb786a5f358748bbe9a7ecd9856d1ddd41151d24658fc54787e4d3ba44fdeb0939a6209b4e180912351", + "timestamp": 1700000000 + }, + { + "proof": "4a9f11a71e3b37d4c4aa9eacbfc7f9d964c829601e8d5b432b5a3a99a1356d8891e4fdf1945d72e4144caf0a002876f28d6d4af1125c558b49355e1aa09076c6", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + } + ], + "min_signers": 3 + } + ], + "serializations": [ + { + "id": "fb817a2821993919bf534c84251bcfcc5c7e90b8e7cd95dec5f7f2f45382fbc3", + "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791465433,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"pong\"]],\"AuGxf6smVEfthQQGjEc7RfZjvuxelhNVWgXq8U9lCjeU7LhXAfh4/ay6DP13CHFgOIat5HZkqU+c+8VM8MBsgusMzh1rwsNEUkiZQOhrA0euCKyw3jmvFOBlX6AqKmlsF3KbOBktE4XEid8dqTcGqiCHLmtPrM8yWInXbx+23puDi1OwZQYtUb96eEw+mVHkzF9604JSNriHTeITBFDGy8nl0WvpV2m7K9z+aopDZmDhOzXzsL7CO3M+kdD74fA/x3+e\"]" + }, + { + "id": "2b44cbb6be46554a6085a77978502adecaaab19c941458695c45c6679c683e1b", + "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791465434,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"x\\\"y\"]],\"line\\nbreak \\\"quote\\\" back\\\\slash \\t tab \\b \\f \\r \u00e9 \u2713\"]" + } + ], + "sessions": [ + { + "id": "ac38cc6453cc51b638264b21403d1a0d21e3bfd0b6577060c9535d016876ac99", + "message": "1111111111111111111111111111111111111111111111111111111111111111", + "participants": [ + 1, + 2 + ], + "salt": "", + "threshold": 2 + }, + { + "id": "fedbf358205097dce691c8d97cc4648fe91461a8b3e1fdd963f725839be250f2", + "message": "2222222222222222222222222222222222222222222222222222222222222222", + "participants": [ + 3, + 1 + ], + "salt": "", + "threshold": 2 + }, + { + "id": "96efbe9ea76d1bd17ca9bfb9046c360fd11293f0fcb6bb63f7cde0cb20daa5c9", + "message": "3333333333333333333333333333333333333333333333333333333333333333", + "participants": [ + 1, + 2, + 3 + ], + "salt": "00000000000000000000000000000007", + "threshold": 3 + }, + { + "id": "aa8bb665d8b44edba4f5a79c7c0f3fa1404b8cdbac725633f3f948563118eff5", + "message": "4444444444444444444444444444444444444444444444444444444444444444", + "participants": [ + 1, + 2 + ], + "salt": "0000000000000001ff545200", + "threshold": 2 + }, + { + "id": "91fe23f1f4037f3ba8b5ddb2cf596113da0c89dbd2d5f7ee9cf3cac721363e8f", + "message": "5555555555555555555555555555555555555555555555555555555555555555", + "participants": [ + 2, + 5, + 4 + ], + "salt": "000000000000000200000001ff545201abababababababababababababababababababababababababababababababab", + "threshold": 3 + }, + { + "id": "a6fa377d472f29241c4a99d6ee1103aa5546f70047f0d2a70a7d6a62d0010f48", + "message": "", + "participants": [ + 1, + 2 + ], + "salt": "", + "threshold": 2 + }, + { + "id": "2663c8f2bc102eb5920b8ca8feb673c416fd05b750a15898d8329cf6bda13e46", + "message": "666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666", + "participants": [ + 1, + 2 + ], + "salt": "0000000000000005", + "threshold": 2 + } + ], + "source": "keep-core/keep-frost-net cdc47dd and nostr 0.44.7" +} From 24a8042e7fd86fb1bd9b7f40af3300a475251f95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20=F0=9F=90=86?= Date: Thu, 8 Oct 2026 09:52:33 -0400 Subject: [PATCH 2/5] Randomize and verify proofs, bound NIP-44 memory and add the vector generator --- components/frost_tr/include/frost_tr.h | 10 +- components/frost_tr/rust/Cargo.lock | 1 + components/frost_tr/rust/Cargo.toml | 2 +- components/frost_tr/rust/src/kfp.rs | 150 +- components/frost_tr/rust/src/lib.rs | 69 +- .../frost_tr/rust/vectors/gen-kfp/.gitignore | 1 + .../frost_tr/rust/vectors/gen-kfp/Cargo.lock | 3830 +++++++++++++++++ .../frost_tr/rust/vectors/gen-kfp/Cargo.toml | 20 + .../frost_tr/rust/vectors/gen-kfp/src/main.rs | 204 + components/frost_tr/rust/vectors/kfp.json | 916 ++-- 10 files changed, 4666 insertions(+), 537 deletions(-) create mode 100644 components/frost_tr/rust/vectors/gen-kfp/.gitignore create mode 100644 components/frost_tr/rust/vectors/gen-kfp/Cargo.lock create mode 100644 components/frost_tr/rust/vectors/gen-kfp/Cargo.toml create mode 100644 components/frost_tr/rust/vectors/gen-kfp/src/main.rs diff --git a/components/frost_tr/include/frost_tr.h b/components/frost_tr/include/frost_tr.h index 04d4b3c..e0d3238 100644 --- a/components/frost_tr/include/frost_tr.h +++ b/components/frost_tr/include/frost_tr.h @@ -115,12 +115,17 @@ int ftr_kfp_rendezvous(const uint8_t group[32], uint16_t index, uint8_t out[32]) // NIP-44 v2 from the transport key to the x-only `recipient`: a base64 payload // of up to `cap` bytes, not NUL-terminated. Plaintext is 1..FTR_KFP_MAX_PLAINTEXT. +// The result reads to the recipient as authored by this device, so the +// plaintext must be one the firmware built, never one a host chose. int ftr_kfp_seal(const uint8_t *kp, size_t kp_len, const uint8_t recipient[32], const uint8_t *plaintext, size_t plaintext_len, uint8_t *out, size_t cap, size_t *out_len); // Opens a NIP-44 v2 base64 payload the x-only `sender` sealed to the transport -// key. Writes nothing unless the MAC verifies; the caller wipes `out` after use. +// key, refusing one too large for `cap` before decoding it. Writes nothing +// unless the MAC verifies; the caller wipes `out` after use and never returns +// it to a host. The key is symmetric, so a payload this device sealed to +// `sender` opens too: the caller checks the outer event is signed by `sender`. int ftr_kfp_open(const uint8_t *kp, size_t kp_len, const uint8_t sender[32], const uint8_t *payload, size_t payload_len, uint8_t *out, size_t cap, size_t *out_len); @@ -130,7 +135,8 @@ int ftr_kfp_open(const uint8_t *kp, size_t kp_len, const uint8_t sender[32], con int ftr_kfp_sign_event(const uint8_t *kp, size_t kp_len, const uint8_t *serialized, size_t serialized_len, uint8_t out_id[32], uint8_t out_sig[64]); -// keep's salted session id (BLAKE2b-512, first 32 bytes) for a sign request. +// keep's salted session id (BLAKE2b-512, first 32 bytes) for a sign request of +// 1..FTR_MAX_SIGNERS participants. int ftr_kfp_session_id(const uint8_t *message, size_t message_len, const uint16_t *participants, size_t participants_len, uint16_t threshold, const uint8_t *salt, size_t salt_len, uint8_t out[32]); diff --git a/components/frost_tr/rust/Cargo.lock b/components/frost_tr/rust/Cargo.lock index e67b5e5..107e6c4 100644 --- a/components/frost_tr/rust/Cargo.lock +++ b/components/frost_tr/rust/Cargo.lock @@ -72,6 +72,7 @@ checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" dependencies = [ "crypto-common", "inout", + "zeroize", ] [[package]] diff --git a/components/frost_tr/rust/Cargo.toml b/components/frost_tr/rust/Cargo.toml index edc5595..b76772b 100644 --- a/components/frost_tr/rust/Cargo.toml +++ b/components/frost_tr/rust/Cargo.toml @@ -18,7 +18,7 @@ sha2 = { version = "=0.10.9", default-features = false } zeroize = { version = "=1.9.1", default-features = false } base64ct = { version = "=1.8.3", default-features = false, features = ["alloc"] } blake2 = { version = "=0.10.6", default-features = false } -chacha20 = { version = "=0.9.1", default-features = false } +chacha20 = { version = "=0.9.1", default-features = false, features = ["zeroize"] } hkdf = { version = "=0.12.4", default-features = false } hmac = { version = "=0.12.1", default-features = false } diff --git a/components/frost_tr/rust/src/kfp.rs b/components/frost_tr/rust/src/kfp.rs index ceafa12..be8f507 100644 --- a/components/frost_tr/rust/src/kfp.rs +++ b/components/frost_tr/rust/src/kfp.rs @@ -25,7 +25,7 @@ use sha2::{Digest, Sha256}; use zeroize::{Zeroize, Zeroizing}; use crate::rng::DeviceRng; -use crate::signer::{identifier_index, E_IDENTIFIER}; +use crate::signer::{identifier_index, E_IDENTIFIER, E_SELFCHECK}; pub const E_KEY: i32 = -16; pub const E_DECRYPT: i32 = -17; @@ -41,7 +41,6 @@ const TWEAK_MARKER: [u8; 3] = [0xff, b'T', b'R']; /// NIP-44 v2 bounds (as the nostr crate keep uses enforces them). pub const MAX_PLAINTEXT: usize = 65_536 - 128; const MIN_PAYLOAD: usize = 1 + 32 + 2 + 32 + 32; -const MAX_PAYLOAD: usize = 1 + 32 + 2 + padded_len(MAX_PLAINTEXT) + 32; fn group_xonly(kp: &KeyPackage) -> Result<[u8; 32], i32> { let vk = kp.verifying_key().serialize().map_err(|_| E_KEY)?; @@ -81,10 +80,22 @@ pub fn transport_pubkey(kp: &KeyPackage) -> Result<[u8; 32], i32> { Ok(xonly(&transport_secret(kp)?.public_key())) } -/// The announce proof binding `transport_xonly` to this share: keep's -/// `sign_proof`, BIP-340 by the signing share over SHA256 of the proof digest, -/// with zero auxiliary randomness. +/// The announce proof binding `transport_xonly` to this share: BIP-340 by the +/// signing share over SHA256 of keep's proof digest, as keep's `sign_proof` +/// and `verify_proof` take it. keep signs with zero auxiliary randomness; the +/// device draws it, so a fault injected into one of two runs over the same +/// timestamp does not meet a repeated nonce. pub fn announce_proof(kp: &KeyPackage, transport_xonly: &[u8; 32], timestamp: u64) -> Result<[u8; 64], i32> { + let mut aux = [0u8; 32]; + DeviceRng.fill_bytes(&mut aux); + let r = announce_proof_with_aux(kp, transport_xonly, timestamp, &aux); + aux.zeroize(); + r +} + +/// The 32-byte BIP-340 message of the announce proof: SHA256 of keep's proof +/// digest. +pub(crate) fn proof_message(kp: &KeyPackage, transport_xonly: &[u8; 32], timestamp: u64) -> Result<[u8; 32], i32> { let group = group_xonly(kp)?; let index = identifier_index(kp.identifier()).ok_or(E_IDENTIFIER)?; let verifying_share = kp.verifying_share().serialize().map_err(|_| E_KEY)?; @@ -96,9 +107,22 @@ pub fn announce_proof(kp: &KeyPackage, transport_xonly: &[u8; 32], timestamp: u6 .chain_update(transport_xonly) .chain_update(timestamp.to_be_bytes()) .finalize(); + Ok(Sha256::digest(digest).into()) +} + +pub(crate) fn announce_proof_with_aux( + kp: &KeyPackage, + transport_xonly: &[u8; 32], + timestamp: u64, + aux: &[u8; 32], +) -> Result<[u8; 64], i32> { + let message = proof_message(kp, transport_xonly, timestamp)?; let share = Zeroizing::new(kp.signing_share().serialize()); let key = SigningKey::from_bytes(&share).map_err(|_| E_KEY)?; - let sig = key.sign_raw(&Sha256::digest(digest), &[0u8; 32]).map_err(|_| E_KEY)?; + let sig = key.sign_raw(&message, aux).map_err(|_| E_KEY)?; + // Recomputing the signature's validity catches a fault injected into the + // signing above before the signature leaves the device. + key.verifying_key().verify_raw(&message, &sig).map_err(|_| E_SELFCHECK)?; Ok(sig.to_bytes()) } @@ -132,10 +156,11 @@ fn conversation_key(secret: &SecretKey, peer: &[u8; 32]) -> Result::extract(Some(b"nip44-v2"), &shared_x); + let (mut prk, _) = Hkdf::::extract(Some(b"nip44-v2"), &shared_x); shared_x.zeroize(); let mut out = Zeroizing::new([0u8; 32]); out.copy_from_slice(&prk); + prk[..].zeroize(); Ok(out) } @@ -170,59 +195,73 @@ const fn padded_len(len: usize) -> usize { chunk * ((len - 1) / chunk + 1) } -/// NIP-44 v2 payload (base64) of `plaintext` from this device's transport key -/// to the x-only `recipient`, under `nonce`. -pub fn seal_with_nonce(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8], nonce: &[u8; 32]) -> Result, i32> { - if plaintext.is_empty() || plaintext.len() > MAX_PLAINTEXT { +const fn raw_len(plaintext_len: usize) -> usize { + 1 + 32 + 2 + padded_len(plaintext_len) + 32 +} + +const fn encoded_len(raw: usize) -> usize { + raw.div_ceil(3) * 4 +} + +/// Writes the NIP-44 v2 payload (base64) of `plaintext` from this device's +/// transport key to the x-only `recipient`, under `nonce`, into `out`; +/// returns its length. Refuses before allocating when `out` cannot hold it. +pub fn seal_with_nonce(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8], nonce: &[u8; 32], out: &mut [u8]) -> Result { + if plaintext.is_empty() || plaintext.len() > MAX_PLAINTEXT || encoded_len(raw_len(plaintext.len())) > out.len() { return Err(E_CAPACITY); } let conversation = conversation_key(&transport_secret(kp)?, recipient)?; let keys = MessageKeys::new(&conversation, nonce)?; - let mut buffer = Zeroizing::new(Vec::with_capacity(2 + padded_len(plaintext.len()))); - buffer.extend_from_slice(&(plaintext.len() as u16).to_be_bytes()); - buffer.extend_from_slice(plaintext); - buffer.resize(2 + padded_len(plaintext.len()), 0); - keys.cipher().apply_keystream(&mut buffer); - let tag = keys.mac(nonce, &buffer).finalize().into_bytes(); - let mut payload = Vec::with_capacity(1 + 32 + buffer.len() + 32); - payload.push(2); - payload.extend_from_slice(nonce); - payload.extend_from_slice(&buffer); - payload.extend_from_slice(&tag); - let encoded = Base64::encode_string(&payload); - Ok(encoded.into_bytes()) + let body = 2 + padded_len(plaintext.len()); + let mut raw = Zeroizing::new(Vec::with_capacity(raw_len(plaintext.len()))); + raw.push(2); + raw.extend_from_slice(nonce); + raw.extend_from_slice(&(plaintext.len() as u16).to_be_bytes()); + raw.extend_from_slice(plaintext); + raw.resize(33 + body, 0); + keys.cipher().apply_keystream(&mut raw[33..]); + let tag = keys.mac(nonce, &raw[33..]).finalize().into_bytes(); + raw.extend_from_slice(&tag); + Ok(Base64::encode(&raw, out).map_err(|_| E_CAPACITY)?.len()) } -pub fn seal(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8]) -> Result, i32> { +pub fn seal(kp: &KeyPackage, recipient: &[u8; 32], plaintext: &[u8], out: &mut [u8]) -> Result { let mut nonce = [0u8; 32]; DeviceRng.fill_bytes(&mut nonce); - seal_with_nonce(kp, recipient, plaintext, &nonce) + seal_with_nonce(kp, recipient, plaintext, &nonce, out) } -/// The plaintext of a NIP-44 v2 `payload` (base64) the x-only `sender` sealed to -/// this device's transport key. The MAC is checked before anything is -/// decrypted, so a valid result was produced by the holder of `sender`'s key -/// (or by this device). -pub fn open(kp: &KeyPackage, sender: &[u8; 32], payload: &[u8]) -> Result>, i32> { - if payload.len() > (MAX_PAYLOAD + 2) / 3 * 4 { +/// Writes the plaintext of a NIP-44 v2 `payload` (base64) the x-only `sender` +/// sealed to this device's transport key into `out`; returns its length. A +/// payload too large for `out` is refused before it is decoded. The MAC is +/// checked before anything is decrypted, so a valid result was produced by the +/// holder of `sender`'s key or by this device (the key is symmetric). +pub fn open(kp: &KeyPackage, sender: &[u8; 32], payload: &[u8], out: &mut [u8]) -> Result { + let cap = out.len().min(MAX_PLAINTEXT); + if cap == 0 || payload.len() > encoded_len(raw_len(cap)) { return Err(E_CAPACITY); } - let raw = Base64::decode_vec(core::str::from_utf8(payload).map_err(|_| E_DECRYPT)?).map_err(|_| E_DECRYPT)?; - if raw.len() < MIN_PAYLOAD || raw.len() > MAX_PAYLOAD || raw[0] != 2 { + let mut raw = Zeroizing::new(alloc::vec![0u8; payload.len() / 4 * 3]); + let len = Base64::decode(payload, &mut raw).map_err(|_| E_DECRYPT)?.len(); + raw.truncate(len); + if len < MIN_PAYLOAD || raw[0] != 2 { return Err(E_DECRYPT); } let nonce: [u8; 32] = raw[1..33].try_into().map_err(|_| E_DECRYPT)?; - let (ciphertext, tag) = raw[33..].split_at(raw.len() - 33 - 32); let conversation = conversation_key(&transport_secret(kp)?, sender)?; let keys = MessageKeys::new(&conversation, &nonce)?; - keys.mac(&nonce, ciphertext).verify_slice(tag).map_err(|_| E_DECRYPT)?; - let mut buffer = Zeroizing::new(ciphertext.to_vec()); - keys.cipher().apply_keystream(&mut buffer); - let len = u16::from_be_bytes([buffer[0], buffer[1]]) as usize; - if len == 0 || buffer.len() != 2 + padded_len(len) { + let (body, tag) = raw[33..].split_at_mut(len - 33 - 32); + keys.mac(&nonce, body).verify_slice(tag).map_err(|_| E_DECRYPT)?; + keys.cipher().apply_keystream(body); + let plain_len = u16::from_be_bytes([body[0], body[1]]) as usize; + if plain_len == 0 || plain_len > MAX_PLAINTEXT || body.len() != 2 + padded_len(plain_len) { return Err(E_DECRYPT); } - Ok(Zeroizing::new(buffer[2..2 + len].to_vec())) + if plain_len > out.len() { + return Err(E_CAPACITY); + } + out[..plain_len].copy_from_slice(&body[2..2 + plain_len]); + Ok(plain_len) } /// The NIP-01 id of a serialized event (`[0,pubkey,created_at,kind,tags,content]`) @@ -233,7 +272,10 @@ pub fn sign_event(kp: &KeyPackage, serialized: &[u8]) -> Result<([u8; 32], [u8; let key = SigningKey::from(secret.to_nonzero_scalar()); let mut aux = [0u8; 32]; DeviceRng.fill_bytes(&mut aux); - let sig = key.sign_raw(&id, &aux).map_err(|_| E_KEY)?; + let sig = key.sign_raw(&id, &aux); + aux.zeroize(); + let sig = sig.map_err(|_| E_KEY)?; + key.verifying_key().verify_raw(&id, &sig).map_err(|_| E_SELFCHECK)?; Ok((id, sig.to_bytes())) } @@ -263,11 +305,15 @@ pub fn session_id(message: &[u8], participants: &[u16], threshold: u16, salt: &[ out } -/// Whether `salt` encodes the key a request signs with: empty only with no path -/// and no tweak, otherwise an 8-byte attempt counter followed by each path -/// index (big endian) and, for a key-path spend, `ff 'T' 'R'` then `00` or -/// `01 || merkle_root`. +/// Whether `salt` encodes the key a request signs with, as keep's `salt_binds`: +/// empty only with no path and no tweak, otherwise an 8-byte attempt counter +/// followed by each (unhardened) path index, big endian, and, for a key-path +/// spend, `ff 'T' 'R'` then `00` or `01 || merkle_root`. pub fn salt_binds(salt: &[u8], path: &[u32], taproot: Option>) -> bool { + // A hardened index could read as the tweak marker, so keep refuses it. + if path.iter().any(|&i| i >= crate::bip32::HARDENED) { + return false; + } let mut suffix = Vec::with_capacity(path.len() * 4 + 36); for i in path { suffix.extend_from_slice(&i.to_be_bytes()); @@ -325,10 +371,16 @@ mod tests { b.resize(2 + body, 0x41); b }; - assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(5, 32))).unwrap()[..], [0x41; 5]); - assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(40, 64))).unwrap()[..], [0x41; 40]); + let opened = |payload: &[u8]| { + let mut out = alloc::vec![0u8; MAX_PLAINTEXT]; + open(&kp, &peer, payload, &mut out).map(|n| out[..n].to_vec()) + }; + assert_eq!(opened(&authentic(&kp, &peer, &buffer(5, 32))).unwrap()[..], [0x41; 5]); + assert_eq!(opened(&authentic(&kp, &peer, &buffer(40, 64))).unwrap()[..], [0x41; 40]); + // Correctly padded, but longer than NIP-44 lets a sender seal. + assert_eq!(opened(&authentic(&kp, &peer, &buffer(65_500, 65_536))).err(), Some(E_DECRYPT)); for (prefix, body) in [(0u16, 32usize), (33, 32), (40, 32), (65_535, 32), (5, 64), (40, 96)] { - assert_eq!(open(&kp, &peer, &authentic(&kp, &peer, &buffer(prefix, body))).err(), Some(E_DECRYPT), "prefix {prefix}, body {body}"); + assert_eq!(opened(&authentic(&kp, &peer, &buffer(prefix, body))).err(), Some(E_DECRYPT), "prefix {prefix}, body {body}"); } } } diff --git a/components/frost_tr/rust/src/lib.rs b/components/frost_tr/rust/src/lib.rs index cb61ae7..3e5caa0 100644 --- a/components/frost_tr/rust/src/lib.rs +++ b/components/frost_tr/rust/src/lib.rs @@ -243,19 +243,13 @@ pub unsafe extern "C" fn ftr_kfp_seal( if out.is_null() { return signer::E_NULL; } - let r = kfp_key(kp, kp_len).and_then(|kp| kfp::seal(&kp, recipient, plaintext)).and_then(|payload| { - if payload.len() > cap { - return Err(kfp::E_CAPACITY); - } - core::ptr::copy_nonoverlapping(payload.as_ptr(), out, payload.len()); - *out_len = payload.len(); - Ok(()) - }); - status(r) + let out = core::slice::from_raw_parts_mut(out, cap); + status(kfp_key(kp, kp_len).and_then(|kp| kfp::seal(&kp, recipient, plaintext, out)).map(|n| *out_len = n)) } /// Opens a NIP-44 v2 base64 `payload` the x-only `sender` sealed to this key -/// package's transport key. Nothing is written unless the MAC verifies. +/// package's transport key. A payload too large for `cap` is refused before it +/// is decoded, and nothing is written unless the MAC verifies. /// /// # Safety /// The pointers must be valid for the given lengths; `out` for `cap` bytes. @@ -276,15 +270,8 @@ pub unsafe extern "C" fn ftr_kfp_open( if out.is_null() { return signer::E_NULL; } - let r = kfp_key(kp, kp_len).and_then(|kp| kfp::open(&kp, sender, payload)).and_then(|plain| { - if plain.len() > cap { - return Err(kfp::E_CAPACITY); - } - core::ptr::copy_nonoverlapping(plain.as_ptr(), out, plain.len()); - *out_len = plain.len(); - Ok(()) - }); - status(r) + let out = core::slice::from_raw_parts_mut(out, cap); + status(kfp_key(kp, kp_len).and_then(|kp| kfp::open(&kp, sender, payload, out)).map(|n| *out_len = n)) } /// The NIP-01 id of `serialized` (`[0,pubkey,created_at,kind,tags,content]`) @@ -331,7 +318,10 @@ pub unsafe extern "C" fn ftr_kfp_session_id( ) -> i32 { let message = if message_len == 0 { Some(&[][..]) } else { slice(message, message_len) }; let salt = if salt_len == 0 { Some(&[][..]) } else { slice(salt, salt_len) }; - if participants.is_null() || participants_len == 0 || participants_len > usize::from(signer::MAX_SIGNERS) { + if participants_len == 0 || participants_len > usize::from(signer::MAX_SIGNERS) { + return signer::E_LENGTH; + } + if participants.is_null() { return signer::E_NULL; } let (Some(message), Some(salt), Some(out)) = (message, salt, out.as_mut()) else { return signer::E_NULL }; @@ -355,7 +345,13 @@ pub unsafe extern "C" fn ftr_kfp_salt_binds( merkle_root: *const [u8; 32], ) -> i32 { let salt = if salt_len == 0 { Some(&[][..]) } else { slice(salt, salt_len) }; - if path_len > bip32::MAX_DEPTH || (path_len > 0 && path.is_null()) || (!taproot && !merkle_root.is_null()) { + if path_len > bip32::MAX_DEPTH { + return signer::E_PATH; + } + if !taproot && !merkle_root.is_null() { + return signer::E_TWEAK; + } + if path_len > 0 && path.is_null() { return signer::E_NULL; } let Some(salt) = salt else { return signer::E_NULL }; @@ -1049,11 +1045,19 @@ mod tests { let mut transport = [0u8; 32]; assert_eq!(unsafe { ftr_kfp_transport_pubkey(kp.as_ptr(), kp.len(), &mut transport) }, 0); assert_eq!(transport, arr32(m["transport_pubkey"].as_str().unwrap()), "transport key of {}", m["index"]); + let key = signer::load(&kp).unwrap(); + let share_key = k256::schnorr::VerifyingKey::from_bytes(&key.verifying_share().serialize().unwrap()[1..]).unwrap(); for p in m["proofs"].as_array().unwrap() { - let mut sig = [0u8; 64]; let ts = p["timestamp"].as_u64().unwrap(); + // keep signs with zero aux: the same aux gives keep's bytes. + let keep = kfp::announce_proof_with_aux(&key, &transport, ts, &[0u8; 32]).unwrap(); + assert_eq!(keep[..], unhex(p["proof"].as_str().unwrap())[..], "proof at {ts}"); + // The device's own aux gives a different signature keep still verifies. + let mut sig = [0u8; 64]; assert_eq!(unsafe { ftr_kfp_announce_proof(kp.as_ptr(), kp.len(), ts, &mut sig) }, 0); - assert_eq!(sig[..], unhex(p["proof"].as_str().unwrap())[..], "proof at {ts}"); + assert_ne!(sig, keep); + let message = kfp::proof_message(&key, &transport, ts).unwrap(); + share_key.verify_raw(&message, &k256::schnorr::Signature::try_from(&sig[..]).unwrap()).unwrap(); } } } @@ -1069,9 +1073,9 @@ mod tests { let ann = &m["announce"]; assert_eq!(ann["pubkey"], m["transport_pubkey"]); let content: serde_json::Value = serde_json::from_str(ann["content"].as_str().unwrap()).unwrap(); - let mut sig = [0u8; 64]; let ts = content["timestamp"].as_u64().unwrap(); - assert_eq!(unsafe { ftr_kfp_announce_proof(kp.as_ptr(), kp.len(), ts, &mut sig) }, 0); + let transport = arr32(m["transport_pubkey"].as_str().unwrap()); + let sig = kfp::announce_proof_with_aux(&signer::load(&kp).unwrap(), &transport, ts, &[0u8; 32]).unwrap(); assert_eq!(hex_lower(&sig), content["proof_signature"].as_str().unwrap()); let p_tags: Vec<&str> = ann["tags"].as_array().unwrap().iter().filter(|t| t[0] == "p").map(|t| t[1].as_str().unwrap()).collect(); @@ -1117,7 +1121,9 @@ mod tests { for (i, c) in m["nip44"].as_array().unwrap().iter().enumerate() { let len = c["length"].as_u64().unwrap() as usize; let plaintext: Vec = (0..len).map(|b| (b * 7 + i) as u8).collect(); - let payload = kfp::seal_with_nonce(&kp, &peer, &plaintext, &arr32(c["nonce"].as_str().unwrap())).unwrap(); + let mut sealed = vec![0u8; 90_000]; + let n = kfp::seal_with_nonce(&kp, &peer, &plaintext, &arr32(c["nonce"].as_str().unwrap()), &mut sealed).unwrap(); + let payload = sealed[..n].to_vec(); match c["payload"].as_str() { Some(want) => { assert_eq!(core::str::from_utf8(&payload).unwrap(), want, "length {len}"); @@ -1233,6 +1239,11 @@ mod tests { assert_eq!(r, 0); assert_eq!(hex_lower(&out), c["id"].as_str().unwrap()); } + let mut out = [0u8; 32]; + let none: [u16; 0] = []; + assert_eq!(unsafe { ftr_kfp_session_id([1u8].as_ptr(), 1, none.as_ptr(), 0, 2, core::ptr::null(), 0, &mut out) }, signer::E_LENGTH); + let many = [1u16; 17]; + assert_eq!(unsafe { ftr_kfp_session_id([1u8].as_ptr(), 1, many.as_ptr(), 17, 2, core::ptr::null(), 0, &mut out) }, signer::E_LENGTH); } /// keep's salts: an attempt counter then the path and the tweak marker. @@ -1259,7 +1270,11 @@ mod tests { assert_eq!(binds(&tree, &[1], true, Some(&root)), 1); assert_eq!(binds(&tree, &[1], true, Some(&[0xac; 32])), 0); assert_eq!(binds(&tree[..7], &[], false, None), 0, "shorter than the counter"); - assert_eq!(binds(&bip86, &[], false, Some(&root)), signer::E_NULL, "a root without the tweak"); + assert_eq!(binds(&bip86, &[], false, Some(&root)), signer::E_TWEAK, "a root without the tweak"); + // A hardened index could read as the tweak marker; keep refuses it. + assert_eq!(binds(&bip86, &[0xff54_5200], false, None), 0); + assert_eq!(binds(&[attempt(0), vec![0x80, 0, 0, 0]].concat(), &[0x8000_0000], false, None), 0); + assert_eq!(binds(&[], &[0; 9], false, None), signer::E_PATH); // keep's own vectors use these salts. let v = kfp_vectors(); let s = &v["sessions"]; diff --git a/components/frost_tr/rust/vectors/gen-kfp/.gitignore b/components/frost_tr/rust/vectors/gen-kfp/.gitignore new file mode 100644 index 0000000..2f7896d --- /dev/null +++ b/components/frost_tr/rust/vectors/gen-kfp/.gitignore @@ -0,0 +1 @@ +target/ diff --git a/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock b/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock new file mode 100644 index 0000000..3a09267 --- /dev/null +++ b/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock @@ -0,0 +1,3830 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common 0.1.7", + "generic-array 0.14.7", +] + +[[package]] +name = "aead" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99" +dependencies = [ + "crypto-common 0.2.2", + "inout 0.2.2", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher 0.4.4", + "cpufeatures 0.2.17", +] + +[[package]] +name = "aes" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35f0f96ce78e38c3dc6d8948aa8163d06385be74000f3c7a95bf1eef35d3ea32" +dependencies = [ + "cipher 0.5.2", + "cpubits", + "cpufeatures 0.3.0", +] + +[[package]] +name = "aes-gcm" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f2b8006a0c83f52b62ba44a97b58bf76fe2f70a329e588f67f89691d93d498f" +dependencies = [ + "aead 0.6.1", + "aes 0.9.3", + "cipher 0.5.2", + "ctr", + "ctutils", + "ghash", +] + +[[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 = "argon2" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072" +dependencies = [ + "base64ct", + "blake2", + "cpufeatures 0.2.17", + "password-hash", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" +dependencies = [ + "zeroize", +] + +[[package]] +name = "ascon-aead" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17453125d1e5c866b1f38bcccf7b9dd4a561f55930c68685ec8f188d01f71c8c" +dependencies = [ + "aead 0.5.2", + "ascon-core", + "subtle", + "zeroize", +] + +[[package]] +name = "ascon-core" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c4c9bc969387b7d7e7e931b978833ab18251a39e0f94addad7b823d08b8db74" +dependencies = [ + "zeroize", +] + +[[package]] +name = "async-utility" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a34a3b57207a7a1007832416c3e4862378c8451b4e8e093e436f48c2d3d2c151" +dependencies = [ + "futures-util", + "gloo-timers", + "tokio", + "wasm-bindgen-futures", +] + +[[package]] +name = "async-wsocket" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c92385c7c8b3eb2de1b78aeca225212e4c9a69a78b802832759b108681a5069" +dependencies = [ + "async-utility", + "futures", + "futures-util", + "js-sys", + "tokio", + "tokio-rustls", + "tokio-socks", + "tokio-tungstenite", + "url", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "atomic-destructor" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef49f5882e4b6afaac09ad239a4f8c70a24b8f2b0897edb1f706008efd109cf4" + +[[package]] +name = "atomic-polyfill" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" +dependencies = [ + "critical-section", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "aws-lc-rs" +version = "1.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e" +dependencies = [ + "aws-lc-sys", + "zeroize", +] + +[[package]] +name = "aws-lc-sys" +version = "0.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27" +dependencies = [ + "cc", + "cmake", + "dunce", + "fs_extra", + "pkg-config", +] + +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + +[[package]] +name = "base58ck" +version = "0.1.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "365c0acd5b2e8dd0111a46c4faea83fb3cfb6e39a49a7c73a06e090db7b2eff0" +dependencies = [ + "bitcoin_hashes", +] + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "bech32" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32637268377fc7b10a8c6d51de3e7fba1ce5dd371a96e342b34e6078db558e7f" + +[[package]] +name = "bech32" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8" + +[[package]] +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +dependencies = [ + "serde", +] + +[[package]] +name = "bip39" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc" +dependencies = [ + "bitcoin_hashes", + "serde", + "unicode-normalization", + "zeroize", +] + +[[package]] +name = "bitcoin" +version = "0.32.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0ce8bd5baaa0d303a19915a6d93afed161f528654e42da2a7a97d05c59499a" +dependencies = [ + "base58ck", + "base64 0.21.7", + "bech32 0.11.1", + "bitcoin-io", + "bitcoin-units", + "bitcoin_hashes", + "hex-conservative 0.2.2", + "hex_lit", + "secp256k1", + "serde", +] + +[[package]] +name = "bitcoin-consensus-encoding" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2d6094e2a1ba3c93b5a596fe5a10d1a10c3c6e06785cde89f693a044c01aa40" +dependencies = [ + "bitcoin-internals", +] + +[[package]] +name = "bitcoin-internals" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a30a22d1f112dde8e16be7b45c63645dc165cef254f835b3e1e9553e485cfa64" +dependencies = [ + "hex-conservative 0.3.2", +] + +[[package]] +name = "bitcoin-io" +version = "0.1.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb5de036369d1ac59d3c1819ebc4d850f89466f5401c571a285b6ed564a4cb78" +dependencies = [ + "bitcoin-consensus-encoding", +] + +[[package]] +name = "bitcoin-units" +version = "0.1.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cb95693f371d089a4b5b6fc41c6f3ea6e01ee8c15388335dfac8ea685173b51" +dependencies = [ + "bitcoin-consensus-encoding", + "serde", +] + +[[package]] +name = "bitcoin_hashes" +version = "0.14.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2" +dependencies = [ + "bitcoin-io", + "hex-conservative 0.2.2", + "serde", +] + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + +[[package]] +name = "bitvec" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest 0.10.7", +] + +[[package]] +name = "blake3" +version = "1.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0aa83c34e62843d924f905e0f5c866eb1dd6545fc4d719e803d9ba6030371fce" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "cpufeatures 0.3.0", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array 0.14.7", +] + +[[package]] +name = "block-buffer" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "block-padding" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" +dependencies = [ + "generic-array 0.14.7", +] + +[[package]] +name = "block-padding" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "710f1dd022ef4e93f8a438b4ba958de7f64308434fa6a87104481645cc30068b" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "borsh" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a" +dependencies = [ + "borsh-derive", + "bytes", + "cfg_aliases", +] + +[[package]] +name = "borsh-derive" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59" +dependencies = [ + "once_cell", + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cbc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6" +dependencies = [ + "cipher 0.4.4", +] + +[[package]] +name = "cbc" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce2dc9ee5f88d11e0beb842c88b33c8a5cf0d1329c4b19494af42b07dbfe8896" +dependencies = [ + "cipher 0.5.2", +] + +[[package]] +name = "cc" +version = "1.2.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "chacha20" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" +dependencies = [ + "cfg-if", + "cipher 0.4.4", + "cpufeatures 0.2.17", +] + +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cipher 0.5.2", + "cpufeatures 0.3.0", + "rand_core 0.10.1", +] + +[[package]] +name = "chacha20poly1305" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35" +dependencies = [ + "aead 0.5.2", + "chacha20 0.9.1", + "cipher 0.4.4", + "poly1305 0.8.0", + "zeroize", +] + +[[package]] +name = "chacha20poly1305" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b89e1c441e926b9c82a8d023f6e1b7ae0adcfaa7d621814e4d60789bac751cb" +dependencies = [ + "aead 0.6.1", + "chacha20 0.10.2", + "cipher 0.5.2", + "poly1305 0.9.0", +] + +[[package]] +name = "chrono" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "ciborium" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" +dependencies = [ + "ciborium-io", + "ciborium-ll", + "serde", +] + +[[package]] +name = "ciborium-io" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" + +[[package]] +name = "ciborium-ll" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" +dependencies = [ + "ciborium-io", + "half", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common 0.1.7", + "inout 0.1.4", + "zeroize", +] + +[[package]] +name = "cipher" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c" +dependencies = [ + "block-buffer 0.12.0", + "crypto-common 0.2.2", + "inout 0.2.2", +] + +[[package]] +name = "cmake" +version = "0.1.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" +dependencies = [ + "cc", +] + +[[package]] +name = "cmov" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a" + +[[package]] +name = "cobs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" +dependencies = [ + "thiserror 2.0.21", +] + +[[package]] +name = "const-crc32-nostd" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "808ac43170e95b11dd23d78aa9eaac5bea45776a602955552c4e833f3f0f823d" + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + +[[package]] +name = "constant_time_eq" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpubits" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + +[[package]] +name = "critical-section" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array 0.14.7", + "rand_core 0.6.4", + "serdect 0.2.0", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-bigint" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96272c2ff28b807e09250b180ad1fb7889a3258f7455759b5c3c58b719467130" +dependencies = [ + "num-traits", + "rand_core 0.6.4", + "serdect 0.3.0", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array 0.14.7", + "rand_core 0.6.4", + "typenum", +] + +[[package]] +name = "crypto-common" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" +dependencies = [ + "getrandom 0.4.3", + "hybrid-array", + "rand_core 0.10.1", +] + +[[package]] +name = "ctr" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21" +dependencies = [ + "cipher 0.5.2", +] + +[[package]] +name = "ctutils" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e" +dependencies = [ + "cmov", +] + +[[package]] +name = "curve25519-dalek" +version = "4.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "curve25519-dalek-derive", + "fiat-crypto", + "rand_core 0.6.4", + "rustc_version", + "subtle", + "zeroize", +] + +[[package]] +name = "curve25519-dalek-derive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "data-encoding" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8" + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid 0.9.6", + "pem-rfc7468 0.7.0", + "zeroize", +] + +[[package]] +name = "der" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a878c850e9e421b20262e9b41f9c860e4785fa07541c266b62ff9d1ef998a80a" +dependencies = [ + "const-oid 0.10.2", + "der_derive", + "flagset", + "pem-rfc7468 1.0.0", + "zeroize", +] + +[[package]] +name = "der_derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59600e2c2d636fde9b65e99cc6445ac770c63d3628195ff39932b8d6d7409903" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "derive-getters" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74ef43543e701c01ad77d3a5922755c6a1d71b22d942cb8042be4994b380caff" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "derive-where" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "const-oid 0.9.6", + "crypto-common 0.1.7", + "subtle", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "block-buffer 0.12.0", + "const-oid 0.10.2", + "crypto-common 0.2.2", + "ctutils", +] + +[[package]] +name = "dirs" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.61.2", +] + +[[package]] +name = "displaydoc" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "dunce" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" + +[[package]] +name = "ecdsa" +version = "0.16.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" +dependencies = [ + "der 0.7.10", + "digest 0.10.7", + "elliptic-curve", + "rfc6979", + "signature 2.2.0", + "spki 0.7.3", +] + +[[package]] +name = "either" +version = "1.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" + +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint 0.5.5", + "digest 0.10.7", + "ff", + "generic-array 0.14.7", + "group", + "hkdf 0.12.4", + "pem-rfc7468 0.7.0", + "pkcs8", + "rand_core 0.6.4", + "sec1", + "subtle", + "tap", + "zeroize", +] + +[[package]] +name = "elliptic-curve-tools" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1de2b6fae800f08032a6ea32995b52925b1d451bff9d445c8ab2932323277faf" +dependencies = [ + "elliptic-curve", + "heapless 0.8.0", + "hex", + "multiexp", + "serde", + "zeroize", +] + +[[package]] +name = "embedded-io" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" + +[[package]] +name = "embedded-io" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "bitvec", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "fiat-crypto" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "flagset" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "frost-core" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81ef2787af391c7e8bedc037a3b9ea03dde803fbd93e778e6bb369547800e5cd" +dependencies = [ + "byteorder", + "const-crc32-nostd", + "derive-getters", + "document-features", + "hex", + "itertools", + "postcard", + "rand_core 0.6.4", + "serde", + "serdect 0.2.0", + "thiserror 2.0.21", + "visibility", + "zeroize", + "zeroize_derive", +] + +[[package]] +name = "frost-rerandomized" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f4c5cedd2426728adef2c0b1720f57676354c473836d1ccc50d0f0d1c91942b" +dependencies = [ + "derive-getters", + "document-features", + "frost-core", + "hex", + "rand_core 0.6.4", +] + +[[package]] +name = "frost-secp256k1-tr" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6fca4ca9f057cf22066f3eb5bbda59d2af51f429f2aac5982a11a8a841c0993" +dependencies = [ + "document-features", + "frost-core", + "frost-rerandomized", + "k256", + "rand_core 0.6.4", + "sha2 0.10.9", +] + +[[package]] +name = "fs2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "fs_extra" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "futures" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-io" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "slab", +] + +[[package]] +name = "gen-kfp" +version = "0.0.0" +dependencies = [ + "frost-secp256k1-tr", + "hex", + "keep-core", + "keep-frost-net", + "nostr-relay-builder", + "nostr-sdk", + "rustls", + "serde_json", + "tokio", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", + "zeroize", +] + +[[package]] +name = "generic-array" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2e55f16dcf0e9c00efbe2e655ffe45fc98e7066b52bc92f8a79e64060a79351" +dependencies = [ + "rustversion", + "serde_core", + "typenum", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.1", +] + +[[package]] +name = "ghash" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5" +dependencies = [ + "polyval", +] + +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "half" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" +dependencies = [ + "cfg-if", + "crunchy", + "zerocopy", +] + +[[package]] +name = "hash32" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +dependencies = [ + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "heapless" +version = "0.7.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" +dependencies = [ + "atomic-polyfill", + "hash32 0.2.1", + "rustc_version", + "serde", + "spin 0.9.8", + "stable_deref_trait", +] + +[[package]] +name = "heapless" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" +dependencies = [ + "hash32 0.3.1", + "stable_deref_trait", +] + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hex-conservative" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "hex-conservative" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830e599c2904b08f0834ee6337d8fe8f0ed4a63b5d9e7a7f49c0ffa06d08d360" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "hex-conservative" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35431185f361ccf3ffc58254628af5f1f5d5f28531da2e02e5d6c82bbc282a10" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "hex_lit" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd" + +[[package]] +name = "hkdf" +version = "0.12.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" +dependencies = [ + "hmac 0.12.1", +] + +[[package]] +name = "hkdf" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018" +dependencies = [ + "hmac 0.13.0", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest 0.10.7", +] + +[[package]] +name = "hmac" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f" +dependencies = [ + "digest 0.11.3", +] + +[[package]] +name = "http" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8be7462df143984c4598a256ef469b251d7d7f9e271135073e78fc535414f3d0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "hybrid-array" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da" +dependencies = [ + "serde", + "typenum", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" +dependencies = [ + "displaydoc", + "potential_utf", + "utf8_iter", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" + +[[package]] +name = "icu_properties" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" + +[[package]] +name = "icu_provider" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "block-padding 0.3.3", + "generic-array 0.14.7", +] + +[[package]] +name = "inout" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7" +dependencies = [ + "block-padding 0.4.2", + "hybrid-array", +] + +[[package]] +name = "instant" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11" +dependencies = [ + "cfg-if", + "futures-util", + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "k256" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" +dependencies = [ + "cfg-if", + "ecdsa", + "elliptic-curve", + "once_cell", + "sha2 0.10.9", + "signature 2.2.0", +] + +[[package]] +name = "keccak" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653" +dependencies = [ + "cpufeatures 0.2.17", +] + +[[package]] +name = "keep-bitcoin" +version = "0.10.0" +source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" +dependencies = [ + "bitcoin", + "getrandom 0.4.3", + "hex", + "keep-core", + "miniscript", + "serde", + "serde_json", + "thiserror 2.0.21", + "tracing", + "zeroize", +] + +[[package]] +name = "keep-core" +version = "0.10.0" +source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" +dependencies = [ + "aes 0.9.3", + "argon2", + "base64 0.23.1", + "bech32 0.12.0", + "bincode", + "bip39", + "bitcoin", + "blake2", + "cbc 0.2.1", + "chacha20 0.10.2", + "chacha20poly1305 0.11.0", + "chrono", + "dirs", + "frost-secp256k1-tr", + "fs2", + "hex", + "hkdf 0.13.0", + "hmac 0.13.0", + "k256", + "memsec 0.7.0", + "memsecurity", + "rand 0.10.3", + "rand_core 0.6.4", + "redb 2.6.3", + "redb 4.1.0", + "scrypt 0.12.0", + "secrecy", + "serde", + "serde_json", + "sha2 0.10.9", + "sha2 0.11.0", + "subtle", + "thiserror 2.0.21", + "tracing", + "unicode-normalization", + "voprf", + "vsss-rs", + "zeroize", +] + +[[package]] +name = "keep-enclave-host" +version = "0.10.0" +source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" +dependencies = [ + "aes-gcm", + "base64 0.23.1", + "bincode", + "ciborium", + "const-oid 0.10.2", + "der 0.8.2", + "getrandom 0.4.3", + "hex", + "k256", + "keep-core", + "nix", + "p384", + "postcard", + "rand_core 0.10.1", + "redb 4.1.0", + "serde", + "serde_json", + "sha2 0.10.9", + "signature 3.0.0", + "thiserror 2.0.21", + "tracing", + "vsock", + "x509-cert", + "zeroize", +] + +[[package]] +name = "keep-frost-net" +version = "0.10.0" +source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" +dependencies = [ + "base64 0.23.1", + "bitcoin", + "frost-secp256k1-tr", + "fs2", + "hex", + "hmac 0.13.0", + "k256", + "keep-bitcoin", + "keep-core", + "keep-enclave-host", + "nostr-sdk", + "p256", + "parking_lot", + "rand 0.10.3", + "redb 4.1.0", + "rustls", + "rustls-pki-types", + "serde", + "serde_json", + "sha2 0.11.0", + "subtle", + "thiserror 2.0.21", + "tokio", + "tokio-rustls", + "tracing", + "url", + "webpki-roots 1.0.9", + "x509-cert", + "zeroize", +] + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "libredox" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3" +dependencies = [ + "libc", +] + +[[package]] +name = "litemap" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" + +[[package]] +name = "litrs" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5" + +[[package]] +name = "lru" +version = "0.16.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39" + +[[package]] +name = "memchr" +version = "2.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8" + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "memsec" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fa0916b001582d253822171bd23f4a0229d32b9507fae236f5da8cad515ba7c" +dependencies = [ + "getrandom 0.2.17", + "libc", + "windows-sys 0.45.0", +] + +[[package]] +name = "memsec" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c797b9d6bb23aab2fc369c65f871be49214f5c759af65bde26ffaaa2b646b492" +dependencies = [ + "getrandom 0.2.17", + "libc", + "windows-sys 0.45.0", +] + +[[package]] +name = "memsecurity" +version = "3.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d5926560aa18d0a437ef884b5f18a61507c00c7268e1faaf6a6e288d89a3675" +dependencies = [ + "arrayvec", + "ascon-aead", + "blake3", + "borsh", + "bytes", + "memsec 0.6.3", + "once_cell", + "rand_chacha 0.3.1", + "rand_core 0.6.4", + "zeroize", +] + +[[package]] +name = "miniscript" +version = "13.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd35e2c377504e50159561884b03610711db6c2fec6c89f2b98d94016684726b" +dependencies = [ + "bech32 0.11.1", + "bitcoin", + "hex-conservative 1.2.0", +] + +[[package]] +name = "mio" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "multiexp" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ec2ce93a6f06ac6cae04c1da3f2a6a24fcfc1f0eb0b4e0f3d302f0df45326cb" +dependencies = [ + "ff", + "group", + "rand_core 0.6.4", + "rustversion", + "std-shims", + "zeroize", +] + +[[package]] +name = "negentropy" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0efe882e02d206d8d279c20eb40e03baf7cb5136a1476dc084a324fbc3ec42d" + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags", + "cfg-if", + "cfg_aliases", + "libc", + "memoffset", +] + +[[package]] +name = "nostr" +version = "0.44.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7d3d987ea7078dc36947cde532637c472a229426702e4331dd7667325378bd9" +dependencies = [ + "aes 0.8.4", + "base64 0.22.1", + "bech32 0.11.1", + "bip39", + "bitcoin_hashes", + "cbc 0.1.2", + "chacha20 0.9.1", + "chacha20poly1305 0.10.1", + "getrandom 0.2.17", + "hex", + "instant", + "scrypt 0.11.0", + "secp256k1", + "serde", + "serde_json", + "unicode-normalization", + "url", +] + +[[package]] +name = "nostr-database" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7462c9d8ae5ef6a28d66a192d399ad2530f1f2130b13186296dbb11bdef5b3d1" +dependencies = [ + "lru", + "nostr", + "tokio", +] + +[[package]] +name = "nostr-gossip" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ade30de16869618919c6b5efc8258f47b654a98b51541eb77f85e8ec5e3c83a6" +dependencies = [ + "nostr", +] + +[[package]] +name = "nostr-relay-builder" +version = "0.44.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08ed09e8363503c6f464087b530a1f43cf68be6292bd4928b5ea1141b03dc11c" +dependencies = [ + "async-utility", + "async-wsocket", + "atomic-destructor", + "hex", + "negentropy", + "nostr", + "nostr-database", + "tokio", + "tracing", +] + +[[package]] +name = "nostr-relay-pool" +version = "0.44.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c85c54d6ca9aae4ae2bf19a7663ba9db5f45f783f1d24aff55f006386b8b99a1" +dependencies = [ + "async-utility", + "async-wsocket", + "atomic-destructor", + "hex", + "lru", + "negentropy", + "nostr", + "nostr-database", + "tokio", + "tracing", +] + +[[package]] +name = "nostr-sdk" +version = "0.44.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "471732576710e779b64f04c55e3f8b5292f865fea228436daf19694f0bf70393" +dependencies = [ + "async-utility", + "nostr", + "nostr-database", + "nostr-gossip", + "nostr-relay-pool", + "tokio", + "tracing", +] + +[[package]] +name = "num" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" +dependencies = [ + "num-bigint", + "num-complex", + "num-integer", + "num-iter", + "num-rational", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", + "rand 0.8.6", + "serde", +] + +[[package]] +name = "num-complex" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" +dependencies = [ + "num-traits", + "rand 0.8.6", + "serde", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" +dependencies = [ + "num-bigint", + "num-integer", + "num-traits", + "serde", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[package]] +name = "p256" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" +dependencies = [ + "ecdsa", + "elliptic-curve", + "primeorder", + "sha2 0.10.9", +] + +[[package]] +name = "p384" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6" +dependencies = [ + "ecdsa", + "elliptic-curve", + "primeorder", + "sha2 0.10.9", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-link", +] + +[[package]] +name = "password-hash" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166" +dependencies = [ + "base64ct", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "pbkdf2" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" +dependencies = [ + "digest 0.10.7", + "hmac 0.12.1", +] + +[[package]] +name = "pbkdf2" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629" +dependencies = [ + "digest 0.11.3", + "hmac 0.13.0", +] + +[[package]] +name = "pem-rfc7468" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412" +dependencies = [ + "base64ct", +] + +[[package]] +name = "pem-rfc7468" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9" +dependencies = [ + "base64ct", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkcs8" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" +dependencies = [ + "der 0.7.10", + "spki 0.7.3", +] + +[[package]] +name = "pkg-config" +version = "0.3.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" + +[[package]] +name = "poly1305" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf" +dependencies = [ + "cpufeatures 0.2.17", + "opaque-debug", + "universal-hash 0.5.1", +] + +[[package]] +name = "poly1305" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a00baa632505d05512f48a963e16051c54fda9a95cc9acea1a4e3c90991c4a2e" +dependencies = [ + "cpufeatures 0.3.0", + "universal-hash 0.6.1", +] + +[[package]] +name = "polyval" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede" +dependencies = [ + "cpubits", + "cpufeatures 0.3.0", + "universal-hash 0.6.1", +] + +[[package]] +name = "postcard" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" +dependencies = [ + "cobs", + "embedded-io 0.4.0", + "embedded-io 0.6.1", + "heapless 0.7.17", + "serde", +] + +[[package]] +name = "potential_utf" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" +dependencies = [ + "zerovec", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "primeorder" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" +dependencies = [ + "elliptic-curve", +] + +[[package]] +name = "proc-macro-crate" +version = "3.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" +dependencies = [ + "chacha20 0.10.2", + "getrandom 0.4.3", + "rand_core 0.10.1", +] + +[[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 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + +[[package]] +name = "redb" +version = "2.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eca1e9d98d5a7e9002d0013e18d5a9b000aee942eb134883a82f06ebffb6c01" +dependencies = [ + "libc", +] + +[[package]] +name = "redb" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e925444704b5f17d32bf42f5b6e2df050bceebc3dcd6e71cc73dafe8092e839" +dependencies = [ + "libc", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_users" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" +dependencies = [ + "getrandom 0.2.17", + "libredox", + "thiserror 2.0.21", +] + +[[package]] +name = "rfc6979" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" +dependencies = [ + "hmac 0.12.1", + "subtle", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustls" +version = "0.23.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634" +dependencies = [ + "aws-lc-rs", + "log", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pki-types" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" +dependencies = [ + "aws-lc-rs", + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "salsa20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213" +dependencies = [ + "cipher 0.4.4", +] + +[[package]] +name = "salsa20" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f874456e72520ff1375a06c588eaf074b0f01f9e9e1aada45bd9b7954a6e42c" +dependencies = [ + "cfg-if", + "cipher 0.5.2", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "scrypt" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f" +dependencies = [ + "password-hash", + "pbkdf2 0.12.2", + "salsa20 0.10.2", + "sha2 0.10.9", +] + +[[package]] +name = "scrypt" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d87af57419b594aa23fa95f09f0e06d80d84ba01c26148c43844cad6ff4485f0" +dependencies = [ + "cfg-if", + "pbkdf2 0.13.0", + "salsa20 0.11.0", + "sha2 0.11.0", +] + +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der 0.7.10", + "generic-array 0.14.7", + "pkcs8", + "subtle", + "zeroize", +] + +[[package]] +name = "secp256k1" +version = "0.29.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113" +dependencies = [ + "bitcoin_hashes", + "rand 0.8.6", + "secp256k1-sys", + "serde", +] + +[[package]] +name = "secp256k1-sys" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9" +dependencies = [ + "cc", +] + +[[package]] +name = "secrecy" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e891af845473308773346dc847b2c23ee78fe442e0472ac50e22a18a93d3ae5a" +dependencies = [ + "zeroize", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.0", +] + +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serdect" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177" +dependencies = [ + "base16ct", + "serde", +] + +[[package]] +name = "serdect" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f42f67da2385b51a5f9652db9c93d78aeaf7610bf5ec366080b6de810604af53" +dependencies = [ + "base16ct", + "serde", +] + +[[package]] +name = "sha1" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest 0.10.7", +] + +[[package]] +name = "sha1" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "digest 0.11.3", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest 0.10.7", +] + +[[package]] +name = "sha2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "digest 0.11.3", +] + +[[package]] +name = "sha3" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874" +dependencies = [ + "digest 0.10.7", + "keccak", +] + +[[package]] +name = "shlex" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest 0.10.7", + "rand_core 0.6.4", +] + +[[package]] +name = "signature" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5" +dependencies = [ + "rand_core 0.10.1", +] + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "socket2" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "spin" +version = "0.9.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" +dependencies = [ + "lock_api", +] + +[[package]] +name = "spin" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591" + +[[package]] +name = "spki" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" +dependencies = [ + "base64ct", + "der 0.7.10", +] + +[[package]] +name = "spki" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d9efca8738c78ee9484207732f728b1ef517bbb1833d6fc0879ca898a522f6f" +dependencies = [ + "base64ct", + "der 0.8.2", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "std-shims" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "227c4f8561598188d0df96dbe749824576174bba278b5b6bb2eacff1066067d0" +dependencies = [ + "hashbrown 0.16.1", + "rustversion", + "spin 0.10.0", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2fac314a64dc9a36e61a9eb4261a5e9bbfbc922b27e518af97bc32b926cf967" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl 2.0.21", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.0", +] + +[[package]] +name = "tinystr" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinyvec" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tls_codec" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de2e01245e2bb89d6f05801c564fa27624dbd7b1846859876c7dad82e90bf6b" +dependencies = [ + "tls_codec_derive", + "zeroize", +] + +[[package]] +name = "tls_codec_derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tokio" +version = "1.53.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044" +dependencies = [ + "bytes", + "libc", + "mio", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9cc2678c2cdd569ef8215e2afd7954ada2ae20b4fdd2c5fe6139a3b02d105db" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-socks" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7e2948f60dbe26b35f2c7fb74ac2854c1fddded0fe9d7548fcc674a246f7615" +dependencies = [ + "either", + "futures-util", + "thiserror 1.0.69", + "tokio", +] + +[[package]] +name = "tokio-tungstenite" +version = "0.26.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" +dependencies = [ + "futures-util", + "log", + "rustls", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tungstenite", + "webpki-roots 0.26.11", +] + +[[package]] +name = "toml_datetime" +version = "1.1.1+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.25.12+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7" +dependencies = [ + "indexmap", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.1.3+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56" +dependencies = [ + "winnow", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", +] + +[[package]] +name = "tungstenite" +version = "0.26.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13" +dependencies = [ + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.9.4", + "rustls", + "rustls-pki-types", + "sha1 0.10.6", + "thiserror 2.0.21", + "utf-8", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-normalization" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common 0.1.7", + "subtle", +] + +[[package]] +name = "universal-hash" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96" +dependencies = [ + "crypto-common 0.2.2", + "ctutils", +] + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", + "serde_derive", +] + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "visibility" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d674d135b4a8c1d7e813e2f8d1c9a58308aee4a680323066025e53132218bd91" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "voprf" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28f59c30c76e2fea54cdece6a054e2662feffa7ab19658a7887524265ee39470" +dependencies = [ + "curve25519-dalek", + "derive-where", + "digest 0.10.7", + "displaydoc", + "elliptic-curve", + "generic-array 0.14.7", + "rand_core 0.6.4", + "serde", + "sha2 0.10.9", + "subtle", + "zeroize", +] + +[[package]] +name = "vsock" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba782755fc073877e567c2253c0be48e4aa9a254c232d36d3985dfae0bd5205" +dependencies = [ + "libc", + "nix", +] + +[[package]] +name = "vsss-rs" +version = "5.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ec751bdcc8bda099e269b24cc6b4ad14f9ce8b0490c1599174070e792ecd70c" +dependencies = [ + "crypto-bigint 0.5.5", + "crypto-bigint 0.6.1", + "elliptic-curve", + "elliptic-curve-tools", + "generic-array 1.4.3", + "hex", + "hybrid-array", + "num", + "rand_core 0.6.4", + "serde", + "sha3", + "subtle", + "zeroize", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.3+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.72" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9473dbd2991ae90b6291c3c32c30c6187ac49aa32f9905d1cce280ec1e110b0f" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 2.0.117", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "web-sys" +version = "0.3.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621441cfc37b84979402712047321980c178f299193a3589d05b99e8763436" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "0.26.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" +dependencies = [ + "webpki-roots 1.0.9", +] + +[[package]] +name = "webpki-roots" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" +dependencies = [ + "rustls-pki-types", +] + +[[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-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-core" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-result", + "windows-strings", + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-implement" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "windows-interface" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-strings" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" +dependencies = [ + "windows-result", + "windows-targets 0.52.6", +] + +[[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.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[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.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1" +dependencies = [ + "memchr", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "writeable" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "x509-cert" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "105ef4642d9cb137ef83d623d0e4bf08b8adf69e9918ca904a174adb6d3d038b" +dependencies = [ + "const-oid 0.10.2", + "der 0.8.2", + "sha1 0.11.0", + "signature 3.0.0", + "spki 0.8.0", + "tls_codec", +] + +[[package]] +name = "yoke" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "zerotrie" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/components/frost_tr/rust/vectors/gen-kfp/Cargo.toml b/components/frost_tr/rust/vectors/gen-kfp/Cargo.toml new file mode 100644 index 0000000..11eaaf6 --- /dev/null +++ b/components/frost_tr/rust/vectors/gen-kfp/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "gen-kfp" +version = "0.0.0" +edition = "2021" +license = "MIT" +publish = false +description = "Writes vectors/kfp.json from keep's own KFP v2 code (keep-core, keep-frost-net and the nostr crate keep uses)" + +[dependencies] +keep-core = { git = "https://github.com/privkeyio/keep", rev = "cdc47ddb120a50a2c31d7a2abd4279845c4dddd2", features = ["allow-ws", "allow-internal"] } +keep-frost-net = { git = "https://github.com/privkeyio/keep", rev = "cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" } +nostr-relay-builder = "=0.44.1" +nostr-sdk = "=0.44.1" +frost-secp256k1-tr = "=3.0.0" +tokio = { version = "1", features = ["full"] } +rustls = "0.23" +hex = "0.4" +serde_json = "1" + +[workspace] diff --git a/components/frost_tr/rust/vectors/gen-kfp/src/main.rs b/components/frost_tr/rust/vectors/gen-kfp/src/main.rs new file mode 100644 index 0000000..fb1fe0f --- /dev/null +++ b/components/frost_tr/rust/vectors/gen-kfp/src/main.rs @@ -0,0 +1,204 @@ +// SPDX-FileCopyrightText: © 2026 PrivKey LLC +// SPDX-License-Identifier: MIT + +//! Writes the KFP v2 vectors frost_tr is checked against, from keep's own code +//! (keep-core and keep-frost-net at the commit pinned in Cargo.toml, and the +//! nostr crate keep uses): transport keys, announce proofs and the announces a +//! running keep node publishes, rendezvous addresses, NIP-44 v2 payloads, keep +//! events sealed to a member, NIP-01 serializations and salted session ids. +//! Groups come from keep's dealer, so each run writes a fresh, equally valid set: +//! +//! cargo run --release > ../kfp.json +use std::time::Duration; + +use keep_core::frost::{ThresholdConfig, TrustedDealer}; +use keep_frost_net::{derive_session_id_salted, proof::sign_proof, KfpEventBuilder, KfpNode}; +use nostr_relay_builder::MockRelay; +use nostr_sdk::prelude::*; +use serde_json::{json, Value}; + +struct FixedNonce([u8; 32]); +impl nostr_sdk::nostr::secp256k1::rand::RngCore for FixedNonce { + fn next_u32(&mut self) -> u32 { + unreachable!() + } + fn next_u64(&mut self) -> u64 { + unreachable!() + } + fn fill_bytes(&mut self, dest: &mut [u8]) { + dest.copy_from_slice(&self.0[..dest.len()]); + } + fn try_fill_bytes(&mut self, dest: &mut [u8]) -> std::result::Result<(), nostr_sdk::nostr::secp256k1::rand::Error> { + self.fill_bytes(dest); + Ok(()) + } +} + +fn seeded(label: &str) -> [u8; 32] { + use nostr_sdk::hashes::{sha256, Hash}; + sha256::Hash::hash(label.as_bytes()).to_byte_array() +} + +async fn capture_announce(relay: &str, node: &KfpNode) -> Event { + let client = Client::default(); + client.add_relay(relay).await.unwrap(); + client.connect().await; + let mut rx = client.notifications(); + client + .subscribe(Filter::new().kind(Kind::Custom(24242)).author(node.pubkey()), None) + .await + .unwrap(); + tokio::time::sleep(Duration::from_millis(300)).await; + node.announce().await.unwrap(); + loop { + match tokio::time::timeout(Duration::from_secs(5), rx.recv()).await.expect("announce").unwrap() { + RelayPoolNotification::Event { event, .. } => { + client.disconnect().await; + return *event; + } + _ => continue, + } + } +} + +#[tokio::main] +async fn main() { + rustls::crypto::aws_lc_rs::default_provider().install_default().ok(); + let mock = MockRelay::run().await.unwrap(); + let relay = mock.url().await.to_string(); + let lengths = [1usize, 16, 31, 32, 33, 64, 65, 255, 256, 257, 300, 1000, 4096, 16385, 65408]; + + let mut groups = Vec::new(); + for (g, config) in [ThresholdConfig::two_of_three(), ThresholdConfig::two_of_three(), ThresholdConfig::new(3, 5).unwrap()] + .into_iter() + .enumerate() + { + let dealer = TrustedDealer::new(config); + let (shares, pkp) = dealer.generate(&format!("kfp-vectors-{g}")).unwrap(); + let group_key = pkp.verifying_key().serialize().unwrap(); + let mut members = Vec::new(); + let mut key_packages = Vec::new(); + let mut nodes = Vec::new(); + for share in shares { + let kp = share.key_package().unwrap(); + key_packages.push(hex::encode(kp.serialize().unwrap())); + nodes.push((kp, KfpNode::new(share, vec![relay.clone()]).await.unwrap())); + } + for (kp, node) in &nodes { + let index = share_index(kp); + let transport = node.pubkey().to_bytes(); + let announce = capture_announce(&relay, node).await; + let share32: [u8; 32] = kp.signing_share().serialize().try_into().unwrap(); + let vs: [u8; 33] = kp.verifying_share().serialize().unwrap().try_into().unwrap(); + let group32: [u8; 32] = group_key[1..33].try_into().unwrap(); + let proofs: Vec = [0u64, 1_700_000_000, u64::MAX] + .iter() + .map(|ts| json!({"timestamp": ts, "proof": hex::encode(sign_proof(&share32, &group32, index, &vs, &transport, *ts).unwrap())})) + .collect(); + + // NIP-44 between the device (this member's transport key) and a peer key. + let peer = Keys::new(SecretKey::from_slice(&seeded(&format!("peer {g} {index}"))).unwrap()); + let nip44: Vec = lengths + .iter() + .enumerate() + .map(|(i, len)| { + let nonce = seeded(&format!("nonce {g} {index} {i}")); + let plaintext: Vec = (0..*len).map(|b| (b * 7 + i) as u8).collect(); + let payload = nip44::encrypt_with_rng(&mut FixedNonce(nonce), peer.secret_key(), &node.pubkey(), &plaintext, nip44::Version::V2).unwrap(); + // plaintext byte b is (b * 7 + i) mod 256; long payloads are recorded by hash. + if *len <= 1000 { + json!({"nonce": hex::encode(nonce), "length": len, "payload": payload}) + } else { + use nostr_sdk::hashes::{sha256, Hash}; + json!({"nonce": hex::encode(nonce), "length": len, + "payload_sha256": sha256::Hash::hash(payload.as_bytes()).to_string()}) + } + }) + .collect(); + + // keep events a peer seals to this member's transport key. + let events: Vec = [ + KfpEventBuilder::pong(&peer, &node.pubkey(), seeded("challenge")).unwrap(), + KfpEventBuilder::ping(&peer, &node.pubkey()).unwrap(), + ] + .into_iter() + .map(|e| { + let plaintext = nip44::decrypt(peer.secret_key(), &node.pubkey(), &e.content).unwrap(); + json!({"event": serde_json::from_str::(&e.as_json()).unwrap(), "plaintext": plaintext}) + }) + .collect(); + + members.push(json!({ + "index": index, + "transport_pubkey": hex::encode(transport), + "proofs": proofs, + "announce": serde_json::from_str::(&announce.as_json()).unwrap(), + "peer_secret": peer.secret_key().to_secret_hex(), + "peer_pubkey": peer.public_key().to_hex(), + "nip44": nip44, + "events": events, + })); + } + groups.push(json!({ + "min_signers": *nodes[0].0.min_signers(), + "group_key": hex::encode(&group_key), + "key_packages": key_packages, + "members": members, + })); + } + + // NIP-01 serialization: keep events and their ids. + let keys = Keys::new(SecretKey::from_slice(&seeded("event author")).unwrap()); + let to = Keys::new(SecretKey::from_slice(&seeded("event recipient")).unwrap()).public_key(); + let serializations: Vec = [ + KfpEventBuilder::pong(&keys, &to, seeded("c1")).unwrap(), + EventBuilder::new(Kind::Custom(24242), "line\nbreak \"quote\" back\\slash \t tab \u{8} \u{c} \r é ✓") + .tag(Tag::public_key(to)) + .tag(Tag::custom(TagKind::custom("t"), ["x\"y"])) + .sign_with_keys(&keys) + .unwrap(), + ] + .into_iter() + .map(|e| { + let serialized = serde_json::to_string(&json!([0, e.pubkey.to_hex(), e.created_at.as_u64(), e.kind.as_u16(), e.tags, e.content])).unwrap(); + json!({"serialized": serialized, "id": e.id.to_hex()}) + }) + .collect(); + + let sessions: Vec = [ + (vec![0x11u8; 32], vec![1u16, 2], 2u16, vec![]), + (vec![0x22u8; 32], vec![3u16, 1], 2u16, vec![]), + (vec![0x33u8; 32], vec![1u16, 2, 3], 3u16, [0u64.to_be_bytes().to_vec(), 0u32.to_be_bytes().to_vec(), 7u32.to_be_bytes().to_vec()].concat()), + (vec![0x44u8; 32], vec![1u16, 2], 2u16, [1u64.to_be_bytes().to_vec(), vec![0xff, b'T', b'R', 0]].concat()), + (vec![0x55u8; 32], vec![2u16, 5, 4], 3u16, [2u64.to_be_bytes().to_vec(), 1u32.to_be_bytes().to_vec(), vec![0xff, b'T', b'R', 1], vec![0xab; 32]].concat()), + (vec![], vec![1u16, 2], 2u16, vec![]), + (vec![0x66u8; 300], vec![1u16, 2], 2u16, 5u64.to_be_bytes().to_vec()), + ] + .into_iter() + .map(|(message, participants, threshold, salt)| { + json!({ + "message": hex::encode(&message), + "participants": participants, + "threshold": threshold, + "salt": hex::encode(&salt), + "id": hex::encode(derive_session_id_salted(&message, &participants, threshold, &salt)), + }) + }) + .collect(); + + println!( + "{}", + serde_json::to_string_pretty(&json!({ + "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (vectors/gen-kfp)", + "groups": groups, + "serializations": serializations, + "sessions": sessions, + })) + .unwrap() + ); +} + +fn share_index(kp: &frost_secp256k1_tr::keys::KeyPackage) -> u16 { + let b = kp.identifier().serialize(); + u16::from_be_bytes([b[30], b[31]]) +} diff --git a/components/frost_tr/rust/vectors/kfp.json b/components/frost_tr/rust/vectors/kfp.json index 09bd69a..297a75d 100644 --- a/components/frost_tr/rust/vectors/kfp.json +++ b/components/frost_tr/rust/vectors/kfp.json @@ -1,25 +1,25 @@ { "groups": [ { - "group_key": "03dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17", + "group_key": "028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a", "key_packages": [ - "00230f8ab30000000000000000000000000000000000000000000000000000000000000001ca02ae56653358880f176602958a083c7474848b9cc662182746be0e002c83f502e9387f37978715f5c309d4cdaf0c2848f1f46a7b4f5f563f49452708f4d20ae403dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702", - "00230f8ab300000000000000000000000000000000000000000000000000000000000000023b29aeffe4009d3cf90462697a7634415a91a16020be006b9f1ab2c99c3dc4a40200715fa60063afec7c4ba944780b0b3ed2a38e24dbde3e5b313e078ec600aa9a03dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702", - "00230f8ab30000000000000000000000000000000000000000000000000000000000000003ac50afa962cde1f1e2f15ed05f626044fb5d9b1b53fe3efad6c106120885469403028300300bbe4b483c81d1d84f2555a633516a806aea54ef22e87b383d1bc89203dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b1702" + "00230f8ab300000000000000000000000000000000000000000000000000000000000000018dd0747b75a6a8b7e4791eddfd02634dd9427e699fa41ab3f081e10c1bfdf568032a46eee8e7b130764621aaedd0bc7d7f3789736901a29b6cdf7f2324dd16ad25028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000002cea4ef8e0156fb1223576815309fc4dc6218b0bba5a80d1067cd00a6fe69357303b6bfacc7235ecc2e5983f10ddc72c5f8d9f9ce753dc8fc8c5354457891c89222028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000030f796aa08d074d6c6235b14c643d266c30400626fc635f311f45c1b5109e343d020c9673e17005783e1374f60be641ebe5fdf3883a009c49b8aa337fd9e3c15457028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02" ], "members": [ { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":1,\"verifying_share\":\"02e9387f37978715f5c309d4cdaf0c2848f1f46a7b4f5f563f49452708f4d20ae4\",\"proof_signature\":\"391d1f37123ae5b3cb3b3ecc9a1691710cdceae8465eab5f786785aee3385e2d07d423a8923ac3706dcdf325c81272088fda093571a5ffd7d2febe2010a5a8ba\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", - "created_at": 1791465430, - "id": "4a2414a73b5cc335d81b5f63d0f68a12885070dcd3538a1f8fff5afbbc73e74e", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a\",\"share_index\":1,\"verifying_share\":\"032a46eee8e7b130764621aaedd0bc7d7f3789736901a29b6cdf7f2324dd16ad25\",\"proof_signature\":\"3e2953876f390b32d4e23018ea7829749fdba003f43023de357bf8a4b9ceb6eea84fe1e7cddc01a3349cefadd12ae04d199b4c2d282c460d8aae14eff5e9fd66\",\"timestamp\":1791467348,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791467344, + "id": "69bba66a30ef1538c312059273104411411ddc8129016198e750da7c55c79398", "kind": 24242, - "pubkey": "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64", - "sig": "5e0d0eaa1cc4f68524b293d37d4089df563092e9f16706a18e093d36c0135bd60d17c516f3d1b1a6591ca3e7ef10c06476dde56a5c2f60a2e318969ec9f58986", + "pubkey": "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad", + "sig": "af866e6e994d2551bea59068b9b290b4b6ee208b381c154595d824303f29b47a66eb52625853406301465b34834c68cc012ad02c96c0a7398060df92508cf944", "tags": [ [ "g", - "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" ], [ "t", @@ -27,27 +27,27 @@ ], [ "p", - "faaa349bdfbd56b3aa3c4c75bd6e0881b55e62f6cc060c8f47e945670976d05d" + "9abc59a7bd6951a409d383d0d59dfcd8185b45b2e07b06dfab536de847397f82" ], [ "p", - "b907ea1ad4e1e18663206f663a887cf120831b93ce2dbb59658f2c84a9502404" + "c579c4bda2e29644907a238471ac5ea5b96c976427a0d39e4c3af9a1c30377c0" ] ] }, "events": [ { "event": { - "content": "AjSEMzH7X/Vly9Qw3XSJVhWdIQvigNQfhaE6dsOsf2ayuu2sPaef4u0p7JY9mVXtUP6fqUA+SAOcEflzl+nRS78txDTsBdHaCRgqKpsuG/pp95VJTcBODwVtcwygQjE33wCGwvzuyFbxhlbSWQFqiwmujw5VTv4v6cIOl1h446tMbdCV2GPdTrKk/BW50W0IQoLo5rSvg7Vurv46QnwT3C0QKDhVecPq0ESDyGwd8H7dCVLQx8/6QVA+XC32i/leZXJP", - "created_at": 1791465428, - "id": "4e62eb062dda159b4aa55787dbdcf87e1ea3a3e2a420fb2697272e120727e262", + "content": "AlFDv6gjLY2za8JzP19i2McRxGWn+zIwjWvx8DGjFWbTsrQlly3J9iIdOpQhmT6ozVzgNuZQnLEzh9+/iH+6si2qkGWwuqh7CwlhwUTfUUmI9Dvwnkahoh8yVqV5TyyeKJJ7aItvsER8fUul6qOyx9yj8skSf5puiMTwgmKzXiMNq2ZGtzPwKc1uS5lr8iRNKIyhG7CpIRxoFLYS6kJFRFKx0u8BxKDvzn9IYLYGYaYfHGnERL+/4fpOr5W27e2QaZUC", + "created_at": 1791467344, + "id": "11c74924322701d01849e3ec383b0685cfac37dcd0e7bc8d98c90117a37b1bbb", "kind": 24242, "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", - "sig": "bd9cd3d3f3b47953bc7034683dd823ea66f31b804fa8d162174a2bf992d1546267e9c9b278756d1b6c55444bd43f554203582aa848fed5f537929ae0cc2ee0c1", + "sig": "4d9cd0ce394ac3b4bd51f0ad99cadc24a36500aa4187dd5f294fff0abbf87df25f1d108e570aed6ce15e59e3fc1ad6c04efaf37a1495622f54bb529ddfbfddef", "tags": [ [ "p", - "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" ], [ "t", @@ -55,20 +55,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467348}" }, { "event": { - "content": "Ar4PmTncBlL5fTWOpD4pvHdewaDZ4vTAGG799AaI/lTSP9X1BpDkzTJiJIcWFDOIeNE1c0ufrEk28o4Ah8IVC5/vonDtNsMJsBVzQN3pqDYzhvZkj0YTi3id8pAaoqujf3C/ROAQMZ6ixBFGZfKcVzjIVEBoqcYq1UPpujyqCzBq3o8oyKN4jM1MJ/YVs81273xT8h1aP1jjS/SM7QKPcEZEjFdm1mui3utTUz3bwA2onfJAXooihIfcG6AxitFkUGny", - "created_at": 1791465428, - "id": "e43c1502624511237af7beaaf17f2263058cd7863166045b99921c17270f90a3", + "content": "Ao+vsUYC55Q+/Ya++v+4JAJZemVpQxo+So0F+OsLCu3iSib0AWlOfPZTk8o1DDBjaxD1TB9CcSXg5eAI7BH87R1rFH/Oto0EZ1xQ6SvmuWBQx/9gDUypwKaXh3rmSknwiM6oUSATU6MMSTiD/0ZmCjv1URx0MFaIlS0y9HCmAKzmwTI3nHM/drkz4C25ZEnMYaH0CMCVRFxQzyRsm63G5wefiTbxlQnP7lyiorgWiTMhaIaJnVFo+ZxHENVTh/Lb2VW5", + "created_at": 1791467344, + "id": "d347417d29df34c9622dcf6c8b22627deb98f9fd2b2b4a1e70bdc2eb209ad68f", "kind": 24242, "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", - "sig": "56d5e891f146f8b61eac8f75b198836fb6955e7e21c862bdff033f9a4c91253026f4e3da19a43215b8872da0898f825d86f02ceb840f45710adb70b5a00b3983", + "sig": "7feb3d796370b4b5a12aeeaa61420f60092b2f0d38295f28281b9a2ad8afa111f916c7dc86a8aa274e813598fbc44e7e3d84e9b9a7ca2af2f6967406c67ade87", "tags": [ [ "p", - "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" ], [ "t", @@ -76,7 +76,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"b81364dea51cecb1f6992de21acc5198e4f6409702e37862f20fc640258150f7\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"dfff7552e7a7eea973869e2daaf025c9c4d3977d24b26b64055df2a0fd101b66\",\"timestamp\":1791467348}" } ], "index": 1, @@ -84,109 +84,109 @@ { "length": 1, "nonce": "dcf6b6cd32390e97181bf43af7076a3181a82d786504e4ac6531a728c38fbe79", - "payload": "Atz2ts0yOQ6XGBv0OvcHajGBqC14ZQTkrGUxpyjDj755hUwJK/wWZEPvt+ZEWL6W6NeASz+rHRX2xjwqicJyPhObMLmq2n6E35sLBQryD57txfiJtgYqeDsIJ4AnJqOXFcZ1" + "payload": "Atz2ts0yOQ6XGBv0OvcHajGBqC14ZQTkrGUxpyjDj75552NjOYHJR6G7qkc90KSbbc5Bwa18Kz+XFrJe6SjctU8kdBLNCYQC/pN2r9RGeHwOEPxP0ppO2lX5jzJNcitEO0s8" }, { "length": 16, "nonce": "48b4b62ce54ec726d14721fa33ea2e6f5ba7b440cd8a312ee7ed8dc97317cd78", - "payload": "Aki0tizlTscm0Uch+jPqLm9bp7RAzYoxLuftjclzF814ZWBehT5lSgqm8zcK66Rnsz4i8e7oKpFoozADYvnQ0OjJoLV/SNr/oxuSr9o7IrS+8Q8BME1kUHZ9LIW+RNIbo9RE" + "payload": "Aki0tizlTscm0Uch+jPqLm9bp7RAzYoxLuftjclzF814hnHsjn5+vvSqf6E9nWjmyGHvcJarTHXhdhpkW5M/0TtfPBYmYJhbBm4bCK5/HBUjir7k+1M6xwhiZLQBm7KvxHzT" }, { "length": 31, "nonce": "9ab333ac2c99fb5751f88175a1bc5e9f58d8c81aa2d058ef89c56fb9c0ec4759", - "payload": "ApqzM6wsmftXUfiBdaG8Xp9Y2MgaotBY74nFb7nA7EdZDKB5YHc5QIwMtgN+HlE1wRMj3f/XqoMimAnWIsnuPC/3pvrwcA5Z+KXlt1iO4oOdokN7XxKfvuaBjqWPr0LzKbaT" + "payload": "ApqzM6wsmftXUfiBdaG8Xp9Y2MgaotBY74nFb7nA7EdZsJEK9wz5ae3kJvblEG2b0Qs6fHYhs65kPom7RSmSI35ITCNlz7O3SiPeSgR6g7w8OGrgdczBSVIQ1eFflDK36wAt" }, { "length": 32, "nonce": "6a587cd0a7f9aa7b9eeabb7a7afaec753d742de3aab2a641c6759cf1c4063e01", - "payload": "AmpYfNCn+ap7nuq7enr67HU9dC3jqrKmQcZ1nPHEBj4Bv5EEBYfAY6ifIqhZAdhR+jhKnBBFDkEuUNg1zlNVoHYJrrYSQ8oYseO3vMySgbIiZg6YNV2yQPy3/RVMMj4iTPes" + "payload": "AmpYfNCn+ap7nuq7enr67HU9dC3jqrKmQcZ1nPHEBj4BzQdC2vaYW93KhGzilr7b+aKPeK8nf5gNynQq3ZfIYTwayMuZQGIa8inKXTeGK3YVXX6xCQSoWEvVjVRRgWUMsvg/" }, { "length": 33, "nonce": "a7022876b07e89c5ac6df59a36ce873bce8717cdbc5d3b9e2be89ab31db1411e", - "payload": "AqcCKHawfonFrG31mjbOhzvOhxfNvF07nivomrMdsUEemG2vfg/XdSVOPiiXkLUPa28DZ9HOG/jvkQBFp/E4nCK4p0rNUTskUukFLNOqT8gl3ZNr3/bhMiNyPKeNEyb5IELs5TgxSXhpyzWuATjjuIEy/XOxGipuLVxN7AwdtvDpRRc=" + "payload": "AqcCKHawfonFrG31mjbOhzvOhxfNvF07nivomrMdsUEebJEq6IXvvfjevAxxGg9wowkiLjNolSUhEYa851QN6UbcRY4vSxaBBpowQxCiiPLBczu2Hyjd+Kcc6y6Q+bLQUqS/qPS3uytPVKefwcH6A+b54KePSHSLHd2V7GgRRGVP+18=" }, { "length": 64, "nonce": "1e18c24039c7407aceed930c4bcbbffe4482506fa0980919601b035c237f6692", - "payload": "Ah4YwkA5x0B6zu2TDEvLv/5EglBvoJgJGWAbA1wjf2aSzQuM9i6fywHC9tqZGvJQrq8nltrqjZSl4g+lbUrC7bBs8vDInTWmCcV+kVbfAGdw62xZ1nnWIq1w2Sf5mS9V1AKC203vtEAHbJNnVvy1dq+zeyfDn2KaD6g/Itf9x/MkXUU=" + "payload": "Ah4YwkA5x0B6zu2TDEvLv/5EglBvoJgJGWAbA1wjf2aSNBqpORrteQrnIANTi7qlJslQe06qHovTEej8u94vdFKOsgYo1NuG60FKp5vPyXuaNJraOeCxPqIQEflCvH3V1gao/GPy2xKpVZ/GjC0yNQErHhnssSYYTqtFNOsHdndyJ0c=" }, { "length": 65, "nonce": "23e76330d01ad81fa02cc808b8b7898bbf56bcbdea77538c17a634f00909c7ef", - "payload": "AiPnYzDQGtgfoCzICLi3iYu/Vry96ndTjBemNPAJCcfvCrSINNEyfbl3dUq9niG53GzX0+zRl4lGuBktReqFh6VnpcTmeTrDQL3/8vPAzskDa3lUvvmz+YlNOEcuWwDGNC9SnPFtsPdvc0saDjWG9zTMG8p1r2B8jt377pLMye94IY2IR59Qw9PAQFNlQ8I4EDQoDVRLlvc4qurkgELmkkuiwQ==" + "payload": "AiPnYzDQGtgfoCzICLi3iYu/Vry96ndTjBemNPAJCcfvMfV/Kt28w3tHDBCFal7OpTgld1fVt1pjtXwp6WXIgkPcM9p2QstaXOO/JaAelAG6X2Ty+U+0oE56jQ6dkhQeZDCbbN1DbznWHGjJNSTDvpMHL7vPxThpj7I7RalDUZ2iOOsptg+HwMnkGMXr8eVg3pyXdtD8qHnUGJEL0jtPDf0Xxg==" }, { "length": 255, "nonce": "a45a569d10dbdbc16a553ec39e7d57c7ae373d5743e4575c939b7af6286194c3", - "payload": "AqRaVp0Q29vBalU+w559V8euNz1XQ+RXXJObevYoYZTDYbQYWM2t0mbRljDvKPIbmn/PSvEh2ADuf1NQpeQWL9/QGXz2kYYA6vApTwtum0ENLeyBs/wez0Bow3qYEFYHZXtnkB6MbQlAly3rWcRSzbFk4raXeQ0Xj4WsFNVR/9C6Y9G5Rfu9xVWhudkg/tF2zhY1Kj6+XCNk2xo5cC+NitTx6ttK9GxgQ7WCts8LP6ddRpNSlxGOPPsQOgdW1DsH6RKHy/MFbCSX4snuCB7IrINEmxuWWc0PXGqFUHsWWz5S1mcpvpkSHpbE0P2hTf1u2eV3AUvCT+aqKf5GrGiqRX69cfK/q8F0yFfUkiIHSRQ2vlC1if1wn6SAtraIf/zwvlKTL5MuurjkQuneOUS44/FCFIdHE7wfWkAFhmP07UzuRmc=" + "payload": "AqRaVp0Q29vBalU+w559V8euNz1XQ+RXXJObevYoYZTDakmGM4COlH+LgLlbYajSTuab3ewTUzkdOZixLHFYQadTf0PfJ+fv/PFfKCkMFsPqyVzfqmZDhMr7nIu3GOiF9P8KEOP/iki00HUjWY9mG7LLWHI54vpzl7EX5ef36SqwEupFf58/CZ0ZHWFfN8s9wxf4Q6MQbbBacEYOUU/tWbkJZT8xM/NR7znBInQ2mX0dDUQnJ9e27y8Kj4mx2neXIVZQ7mrPtbYD1WS7tZd4udxAaohGgdE2/IFd4kGtx21ieRotOaD8jMyvM1cM1pKx2UIm/QbTrGccKBWnnF5d6wY7SDAvnpaJgAYgutdJQQ2w6CV11ejc1aE4JXFoCa2tRmBRxuPYpq+lqaHlCVNFbYzXLX17qFxRhFhWhgBpkWHEmvs=" }, { "length": 256, "nonce": "7a57603ffceeac0e818711589991e97122d189d97482f8ac65f5419b3b8d8ec5", - "payload": "AnpXYD/87qwOgYcRWJmR6XEi0YnZdIL4rGX1QZs7jY7F6KvJg12MpX0Cjaerv0iutGca5ZlvOeE9e1z47y0/pDcQCrHFBp5sE6kXuhD1wcqY4LczEfg7nKNRoMFfUuZU3VsB3t3h3258mEMseVRafgug17xi6qW8/k10jKOhweLVrDerIjhIRcwomF0w1g1HNM1Cvnd6IPMqODK2K63HNl0JTczw888tASmaFkZun7AAhGeVUjLd5kwrF+yBUeZaI39SapLDwZoxhZFY1lT7QDkxzk13eBxUa02lrlGwPxSrIwIacOw8zwiT/pvjSjEDW0ECaCA0wjeJvdakeNj+Z+Ih1eNwv462M3gQwoedTcA2xA19dPtDJNyPKdpgcZ3pahROUb/M9eRjbBfVdoNoniW/ER+JfuwWT2ebGPzG+M1hrlQ=" + "payload": "AnpXYD/87qwOgYcRWJmR6XEi0YnZdIL4rGX1QZs7jY7FfdnORQU7elQtf4qFJ0vsTWceOKzRLs/BAiLJ5pSNrZwbec3EK92oydJlB4OFirpb6WqbqgY9E+rhrvmOR/ifWVld5sqGAdrOflyUH+Fkfwc0uBNgcU4HjJj7WZUefwFUH0dWCoWewVOX7ClCaD3pIxFijT7E7YaR/SVQ0cTNRCcQB50VYdEkS0Ds4ccZmGsOonTeCjrIaFt+MzGer1bs6xv1dJbxj322/nt33g/AmQhpK7C+phhg9UBKKnVzgKbEknVRXmbyM/Wf7Amj8OhgyQmjb5leQqHPdRZT+glQbTHXvyiQJzA17EMSNdAdBV7zZCMjGFttGv5bft+yaZj89wWUK82E87QQnbEY6y3NVbiC9oXVXmIHoVPbOMugCXVPq+Q=" }, { "length": 257, "nonce": "fd6bf9705d1bfe6d0eb64e0d4706a79c6c99d072c7cbc7f7ffd49361bea39e69", - "payload": "Av1r+XBdG/5tDrZODUcGp5xsmdByx8vH9//Uk2G+o55pJV3ZDrZ2OXFjn4iJnjGdbtIRwxNKZuHe2+tfQzk0ljI8gIxTC9fk3HkwsjL810/w2+GYh9FN5te4VGJhdgz63VdoUwgeeHItLmKcUuCWbKanfJDbHNkNopi+UJqP/JmVLpT5Z+nWo6u3ahoASnkyeCri8g2AGGoCNxjt8bgrBwK93clSlEWNw6m3Gm6t3t+LwkudIyLsCpGtijV/oPiOBoUOBCFY/+5ebpBRfspvaM97TJxScWtwGqWL0eu9dYxhuzKF2Dkgx+iC3NCryaPSXa0Ttwzk0O3toA0p3C+oJA6hDLwjR+WlMqkUxE088UQjPl1jzDckjC/n7fN2/uNYdxAyvWc932ex3RGzNjYcU5sfn2XqfQ8uU7/YQiniT8CYXKKPkVkjnEcqwPdTsBYBkyEgB1myDPLjw84IuQQHw3iM2R6wWq0ZazK7/CBrUYrWH5l9gIM1D8IR/Whe5fbczRd9" + "payload": "Av1r+XBdG/5tDrZODUcGp5xsmdByx8vH9//Uk2G+o55pQ0i3TaO5YwCwJwgeGa55BELC0GmZ8RN+T4igdgzKZF5srvIV2fSqXadxCIhxpW2xDBsuqa8zoT/E1seULVwYOw5XMem9HiOhDp5BS0uHjngH1QvNSsVgalb9sGI39bBGW+KXnGFXVaxrt942wVRqPdTXQ6CjL5FM9prqkgPMWKoi1eyOYKeuk1EAf1mSpESQESjlXQvf7msXoB594d34bfDoWZYxhC0J+QKCAa97Lr8rIIg4zXnNnp9gkJtCCShGBCTHxl6E4oK9IaSrAe0xwsRBYles01KejGSN/JCfkWZbPqnlMvJzjZabPgzlo+FymthGf4XMjf22jJjyLFois77TFiJStF7CrZlWJv1CJ+A0d96boaGeQLM8oTfiWp+9+WwI3Bga4aSyNAV0vuatlG7FOe6RbvptmngXstNhvcPNM8xbFZGJLkyE1Vg9W8/CX0bCD53RB/Ncg71jjmu23Ssp" }, { "length": 300, "nonce": "8aafaa2134326197d827571d8f2052d6115065a0f309e1f80828ad3064622ad7", - "payload": "AoqvqiE0MmGX2CdXHY8gUtYRUGWg8wnh+AgorTBkYirXjgKRmvGA1BhEWx8QrtjkLZB7hRqgxr/nkGfWGmguaT/M/SaZsR9XDlW9MpghI3KtnkaKHYVJvq6brEdnezVs8wvF7tfJoLnXGfkg8t7ae5FuYTPEgGwjhBoeTnCjHac6o04ErbmpG9SJfm1W70XuzczBYEoPsjyUT0lhiL8ADkiTqdfYd7vH2iBt0c8shb2gx+j6cEME6OfGGj1Yv3Bu6WW0j1L2SWarTpDLmST++J7Eru8Gg1pB7z7ox9GdqaydIGK5ROjZ2n20ol3UJnn1oCf/xq8a7ZhXocarsUW5VKKa2REKEHLWUdsR7hJgbauil74SiGXIrC4sg05Amm03YF4o961mSqlkoH8sY4bjh8KIJytrrnY38BlsMr4HpDR0lq3PBpbrqbpF8DvcZ6xgBZALMcU3HzZUH0VkDUQf/3gTO8+0e6fZPW+8jiqFdZenU8imGuLiO61xu2gFdMG8Q1lS" + "payload": "AoqvqiE0MmGX2CdXHY8gUtYRUGWg8wnh+AgorTBkYirX/BcmK4PWZ4E+dTRfXijdBUcN46eMhKxvdCCYZzNPpbaehKyrqk2Zz7RIHHi3xRcogcWCCm2UfSYzLm7tSt1e1TzwLQRYGpFb4IuUZFlxvp3W7ImKCzB3N2qnKvKq6T8EQ/HmpqUwx2JXXg5eawIbvZYd9VXZLaPnBZWnUKcJm2Ct7DCxujDS1AR2xPggvKhW7G4NYn1Pk44XBstIBvVda0OaQJjX+LARNRTJNR4RmqUu4zidwQ8K8P9krbzTGwhsRZUMH2+W4iNApjntAyp7r6Y/iR43dEcHBsCDgxM9i1i+G2YLBhTPCFzrzv+i1hxnSaHlYsf2Wv7U0HBEiTE/LcFLTZcRcSbSb7W84Alnf6DLye1zsk9yvusDg5raV3IaNsgncyr4+mybF7E5+WpaIMcWNU8ZqsF0ahGMO69oevhUXCSmapphSTMhzV3zPeJuAsejVLvqLfBV6ha9ElPNp/zK" }, { "length": 1000, "nonce": "f8d276c0db3eec61f9a59e58096f89efa0a9a1b59579ebbb4fe3ed5076300657", - "payload": "AvjSdsDbPuxh+aWeWAlvie+gqaG1lXnru0/j7VB2MAZXJoIfZPlCIX9ctde7KNNJECntPg1Fn0CrvnKZeOnYhpjn2vnuOW4axF1Aaj2gE0NISx3etPHPnATeCF2S17M5I6WDETNl00v2WXnGceKir8xTaOPvnKS+iXdtAapGds8ZzBytj2OFvNvN8UMYyJHAlB9R10FqTHE7dWbRapva2D+aLRBmVClN7MyPuMU5/9v30IF/F+5AEyTIglL2SkT6mDNrN22qE7gSVPhkDKYoZdpvuCJk2OtC4QIGfx9QcO7aDb6w7+AlmZ4Dx8uZpwUOZrqyTrxrfQcoDHIuJ3vV/TxCqq0O4+wT7PsRsJQWE8o/iDrSyONOUEa6Njoq7Lp3xEQ9gm/3zxy2SWRKW1mIIkQYQa6+TG48WaG2EsdB31TXzkeu+TA2og7cwXAYq28vFvuKltuckrbchPAoPJFqx1HOlfw6Hy4Sfeqm4SKxpfEbJOAag/HB6h82/gsnGBrEd3bk01Z6EE/Uk0TJUj9fLCYEPXBU+o7GWXQKIIpX5YElcKNiL4qbqSRAoMcVQXXidRKzS7AC/lSUgzZauXDcuVFnsGUjcMSkwMAjNOMgI8X1HdDSso1zSEotGqK/x2zj91qq0acORykR8Ma2mmY4MEemhwAi+57p/MGciiW8izzF48hNIeZ7MiNL5A74K0StPGfHpDt01KJAM4LWXl9jzB1JTi4imbxLxb328X6N+a+y1mfTQd7Me9dyKOIO1HCq3oebBYJ8iBM5lYqMJFeskIQ7jrXamBMYJyDXkViy6EzSLbWJHJWLSLR50+s8rUbgofAJwoZil+r3GNw/PtNEOYNe07A72ZaKKOyPUsCbmpJQQaLTGohGYNRJw4pXrmC06+USxoK/KbV9KjdNF2aay0iVIG1lqImkQSrP9zDVEn+J+FO8Jbf+BRm0zMxeNLcJCvgpRWHyUcml5TYOR8B06UXXiA+5Oicn9biSLf9gjJ3qvnquT9kkwwhlTfxuwkvqZfM42WImWCtmQrlBjJe7HKT0IKjxeWlxpoyLFX+lDlBHQFoqEV+xZ5U2z6gGa+Ir+JSevJ7qq65VdPs+exHK1iOHU0Gw8IBLcy/zX+inB2L+6IGVPHBdDR1/mSqkH0IKrxWZjLMkXZB1JLIe7p6+x5vyZ64kDoDSSOJdfJQPT2Uq4r74/ZfwunZBZV9VDp3J3nErsqqfBAgAV2agrAYdUN/nhNhrtu6u7JZB1sYM00sBLhiCqJB31YRoM+v7qdrlSHKBTsu2s6FH10IUU4dDJ5k0yb6BLd92TnXaqocZrVRW2T2JX1fed+6yMel5w02FXb2X3Zb5zLLdfL2XWZlNEBb5KR73VZZue1Rzxvy1AMB0umiJB7eFblJmAuBAv+fQge+Ebq/Ci6+RTfbHl7Cq7OMXPfHGHjr+btH5/H+gubCownY=" + "payload": "AvjSdsDbPuxh+aWeWAlvie+gqaG1lXnru0/j7VB2MAZX4edf1DwMxU0t/atczMWyTwpfefK/Av4cD5tsVFVGn+/rrYqEOvn+Vt0z3PkhToNPN21Sazciy5DOtPxOx5jVA/yaqbmdyulQhLa6MY1yzTsHFd/VcaIuOdTF29xMLRx5EUqlf2buKcix3xuy4D+RGpAV3s+rubHCKwRt4G305SAWXQoMEj0Y6b9R28E2oLSAOIen+zclAO4poHp32FGknrDaKtt7GsXojlKx02eictixaEQCo/+CU3PUBvEG7Oy0epxXQxHTbS5IthFryoRRP8b8zGB20m/EsMy0QRbgSGOr+zHR/P+nDlL5look0/ORsMeLM5E43CZXlgZxB4De/CRtEUrUg49sjuyg+gNJkhH5zrrD3CMk3CJJtFzHgIBiUg2ugf90NPaM1K49wtRdDNMKAigQLE45+Dc/imHo2k1p7HlKIsOK0zzxNnv8ZMWK3H0y/ED/HRfoEVR/1nVAe6wtrn79BIE8iziVY4pUxa0AofgSQ1u28OWNfjUwAHsIziSQ2cI9vMc9KfwFYiGw3VRIz/SxOHmSkEF3i2aDYexjhu7OxI4GQdXfOSmJViBaGmjr6S0PR3TLWC4fAucx6eNrR/rwNl+Jy7fGnmwLEZ7tsR26OJkAFOXlWldq7BpVX+fbH/pm+GCOEJN49zaYs1rfOUIfKpfF5ZENIBPYhXWtdS7ovxOmlxW+fR8SdqxRdOXcpl1kSKY8VaA0qpAMZ9yJesHFeX65V9nmm3aESGw2ratYVcrpGlbVd91o5igOxNHan3NZNdpMk5ugY2FwCfi3EE7fMaLqtbIJj6ya7olQtM1tHidrCgmP2ItYWo1L4WMQFHVv1ZQ7Ez/H5BzSYVq8oVtAz4njIs2pTK1G4zebAUwZ2fW7HuvE+jA4yD0GUmmid6fKwUb8fz0tWuBJPeeoop+r5wnGtjeEvK8EJStfT7qknk0oSausHUGKxhdfznC89BDzUQmiCQi9Q3VAy46eg+rZUc5v9uS3gwSpPxpOMUyXJ2RZTXxy4WTThf+UgJ0M0RmNXc5Azg2Bbsm+pdSLlgDIm7c1hCW0hYnKkdc9ifU37eFPQTZOemtP2VGg646F47uNXfVfjAiy/7THQGbYxNdVlWZSZUssIfyMFvBJMadG3ZLs33yw6Qt5IEMd4mkAGwVf+YR/xwjEEmSHURVHSOBxFYpbWg+4I0zH/nZGp0Qo1GOix/U56ABGtycRuZiW2aq2z332lDJifI0NbBU5WWIBNmmLKPG+ZAUpRUTwUDkmwt0mRlTyhuyHn3LL2h4pQgx7x+TcKa0gq63o2HR9iol2CN4OCH+7EUM4kZm6fF0fvfziH78ptWUFprGdkt83uIjd8grfZdd5mtXKmEDq8Pe2ampRk5lflgl0dtVWkKaqCi2FUmKBFBs7oYRRnIM=" }, { "length": 4096, "nonce": "6a65f86b1f120723d8751d74d937dd490bea1ce61e830f3d05d5c6632d216697", - "payload_sha256": "6db9d0069a871a1f9377ffde58a40d5b2c5cef98e04e87db12d58bd0140b27a6" + "payload_sha256": "5300dd682e29f84e412f8be1a74b544e18d2c55492d2301aecb6aa1193a9b03d" }, { "length": 16385, "nonce": "8f463a85648ea678abb43a6706d9b3821d45b3f68584c9179399de5277c555c5", - "payload_sha256": "562e432b890a2a40c4591a14bca67e28eb9b5daba4ca7a30a83852ae1e2d1f20" + "payload_sha256": "f877326cbf8023930b9834704afb2e7211dc077c400ee4268ed0443fef1f02f9" }, { "length": 65408, "nonce": "c2c2c44e23f42580de972f3c5b607e01c8c3e5ccd50720280ab374150658dcf7", - "payload_sha256": "f05d3cb541dade55466a3ddb19ca10c068d2f815ef49a153cde6e586b904f90b" + "payload_sha256": "2f7da24f024676a247223b5626b859ca4a1b7a8e15f1535ac09a1433180d5309" } ], "peer_pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", "peer_secret": "152de0e509e2a5324b88f1286ba08b3206243ca7ea574672f7c85e2143341df8", "proofs": [ { - "proof": "9eed2417eb3d57799e94daf2e7743753363c0ff98c9d82384e071b4daf3272f4b6061d7f266728f095588d6ff10812e11d93bcc38d3d2cbc770908e892474e74", + "proof": "c867e649fe2c9eb18db1991f8d4d7e34c493dce8703ee82f71deeaa97659343c7eb6f1625bd6bba25a5d13bc4858e11c04d9cd9d2086beef87acbb6833988511", "timestamp": 0 }, { - "proof": "cbf85caf83d7ef31d04d8028cd2b2da086f984525bd309664488cf5b49b6667928058ae3f075b509bdf0917fd666b4e64086ff3f7409fce6ccf552e0f99573b3", + "proof": "2322583e17c68c90fb4d7b951f0182b669afc74afc3fe00893475a717f129dab3906a7c64508fe69a516bddd130b57bac1ed321a27494b6cf36c10ca084f1d09", "timestamp": 1700000000 }, { - "proof": "d4cb9e2a21d382620d67b96523961dc21d7946f5b9af5a9ff76e429b9d92a72d31b2163f610a364156003259d14492d8a813b8c8529c77155a7e0233a168c13d", + "proof": "66e2233dc41169f40633bb61cd8c1aa02a5713ec58fe923a14ec3ce6b1f4e957b54e73ade24434ad6e1f15a7c560ed9dea4350dbbd9a16abdc595198f463d1f4", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "8445e4609b0d5cd45e91973ede56b7e0cc971bfea8fd22165b05fc90ee093e64" + "transport_pubkey": "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":2,\"verifying_share\":\"0200715fa60063afec7c4ba944780b0b3ed2a38e24dbde3e5b313e078ec600aa9a\",\"proof_signature\":\"26337784c956f0ed4176de32c5906b0c3d61e5aeecac5666396aaa2bc6fe19db60cc4ecbec7cfed8dc2e60a7610ed795a12aa5cecc993e10c22c31650110cead\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", - "created_at": 1791465431, - "id": "c5f807ccf9e0353b668c625199b3e3c4bc07671e5c9d5153e015b662f6cbfc35", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a\",\"share_index\":2,\"verifying_share\":\"03b6bfacc7235ecc2e5983f10ddc72c5f8d9f9ce753dc8fc8c5354457891c89222\",\"proof_signature\":\"0416a88ebe46c684426bf81dc1bc3082729cc34a02f79c6adce48ab050ca4f1bdc0c617fee8fff12fefec419d9e01b31e5ea2fe5bc647117edd0aceafd353d6d\",\"timestamp\":1791467349,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791467346, + "id": "b89c18644c75e0876fd966b969787b596ef32d9269e5eecb22bf88c7a36b0f11", "kind": 24242, - "pubkey": "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07", - "sig": "107475e56797bec6a0adcd0afb6cb8b7cfb8962e128bcc273929214bea7261e1faf4c707bafc74ffa4dbc3d3f6d906ae0d134ed7276098d6ca5a0b2944cbeed3", + "pubkey": "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609", + "sig": "4329993d6ebdb7293d6d2b14a8e1ece69737379b412311d1b303b5dce63871058b65a7a963bbf7db33e8419e484d8e3f5c2f8ea213e6f8463f42befff7835c59", "tags": [ [ "g", - "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" ], [ "t", @@ -194,27 +194,27 @@ ], [ "p", - "357fb06973fe9f1aab420064cae67d4a08bc94b9b14c277a2bb4dfa78c3ca71c" + "c8105cdfb67c25d7c16cfc8766b6affc2d8a5a9acf149e3abbce80385d7f1d90" ], [ "p", - "b907ea1ad4e1e18663206f663a887cf120831b93ce2dbb59658f2c84a9502404" + "c579c4bda2e29644907a238471ac5ea5b96c976427a0d39e4c3af9a1c30377c0" ] ] }, "events": [ { "event": { - "content": "AqNlosWO19lYetgEYJuHyLNO0IaJ9lHtTQB7YwgLzOjkpgg8EVJrLQbT2JQ3lEh4jYyXw9smjocurwzz+y+m8elj5SxCSxaTNIc31/b2jrsmyYk532/WDbyN4uaj9eeKlxEssKIwoN/AKFzyIkB9dv1LZTHqu2zqNyq6GOGgVkl0OujZZG7E2N/DtWOZCX7JV33geSSznyefyBzO2+tooiNDkU7Ux8ODnPz4k/vfiN2aMnTzT+su3bUk3hGqRrF5z456", - "created_at": 1791465428, - "id": "03e3fb0a2f8e447be7604ad8a1e233541022baf373c227a7f9c85c3ec20196aa", + "content": "AsJWHuaifEFl6VNr8CgxsXcv1eyIEGL90ivUGIDQT3Ygj5is0GfFVtYuYmmpArYwUXeNH3KpCHywpMLthYfEXAWZ06QQAfsBZvmHVOw8KHTh3SdbI6xp022gGTaTZtOndUDrxnB4+fxqRanO+84hnXXUzwxfHMVzqhl8tVcp53QkFjCJrQJus8AFDwHzotgC9jDP2mb6IKxqeppe2SRqTo60HOtZvRYioZXL7mo1yy/PTwE6paBLYWTZWCRRA1vvN8Ok", + "created_at": 1791467349, + "id": "38139792b3a43e565d617c109ff1101161d71ad3b1ea6575c3be423e471821b8", "kind": 24242, "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", - "sig": "7759bbdc94702deadcaea61b2e1b12e6f9ad7afd77af257f1ac220c5892b0630e6d5fefb6402cfbb40b8c7521c15e07b725b72cff35765623671caf1e211c4a3", + "sig": "fb4c6eed35cda5ec2075c9b0414950e0bfc195b2e423e0cfd9d6e5675277cf27e63011dde1e7f6ea909564364608e9078f660528de31f57aaaccf503e408edbf", "tags": [ [ "p", - "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" ], [ "t", @@ -222,20 +222,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467349}" }, { "event": { - "content": "ArbSQLY4qBxrdjLhkR6ST1jIndp0Dj7oX64hY2dcTuLPF2CeHG8g9S5YeotGateVEcdRhxo+jRWBj7vpOM+BvdDD5C94hZiEMbcGoPbMSW+fzQU46GmRsajOAWbZU3ffrL/iqsq7DstwIKTrj6o944bC8JkJnJ+5o4xXIiDYAeEkXxoELnpDdX2gFTrq2XEGbhV5NZxlQdfUzl4l2AyONcKAOKkUJ/RH/Cej6GKj5wzQ+PgVOhxIUp75s+P9rGqixXSe", - "created_at": 1791465427, - "id": "3111da328e61b6621dcea9f90455e92577802f71e425ac68af1a1c2202d12349", + "content": "Au4za+9ER+5iLctE/AoVsyelsMdhIozpJnQMc5ebs3hDiLGbqG/zv5NGal7a2iOK6MHCj4bD2f33EvQTURSrfNSnC78WPJbRnn93k5v8G9uY73IvRJlUWO3TOzc2yU70iKpbuKhlAMFqnLKsTJDkKCWHYKcsQ2UzL0Dl9WxBY+bHFORs2SwCiOs6WStLcK5TPR7h3oSppq0GcSiNL/uL2PyhjwxD2zT/qU4PGU0h0ISlabRuMYScmSAZUTuG5qG1ZMBb", + "created_at": 1791467345, + "id": "cc1c709d33b6f4d5c30dcbdb1d0fa04b0b2fff108777957669b60c4c82bbd920", "kind": 24242, "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", - "sig": "b403db38796111311114ccb6e57b5f8f3835b780ee9396b01cd92a1380e7aef6ca87942d43c8d596aecf8613b24832ff403eb13708c5dbd642edf906f9d9235f", + "sig": "c888f7d568d9d2bb40b77cd7251652d26044d466dfdf2d90eb26353f722993da2ccd20a101a3e77aa1b1297b52dac37289b89050e33d65a74e85fc22c1b8c371", "tags": [ [ "p", - "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" ], [ "t", @@ -243,7 +243,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"382bc6222087a6a97bd562ea63b8d78e7c6bd3b0e7ea7a85205d24bd3a77150a\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"76883da1f2f7fc7ce3a7dc073114a0036d7c3f757711ae560f2c859dafc6e02b\",\"timestamp\":1791467349}" } ], "index": 2, @@ -251,109 +251,109 @@ { "length": 1, "nonce": "b8f2e6775f251ea98d6a8ef5a5f140643e479defc638cf0b440c0ad3a9106295", - "payload": "Arjy5ndfJR6pjWqO9aXxQGQ+R53vxjjPC0QMCtOpEGKVwrGICULEWi1H8SdG/+XE1EYPxQxYJqa8Ql7RYlIWH8AZ9eJ2sx20Zgabifw0pgbaOE7FuzPoIL5x/ayb9+VgOEtn" + "payload": "Arjy5ndfJR6pjWqO9aXxQGQ+R53vxjjPC0QMCtOpEGKV8xVK7082vIZ8jV6lLtfXWi2UdQkpabPmjcs5W4j5JRP2hE8UTJYv7+1E6IkGHSQh0Jmops0ujEFSKebk0CK4Il3X" }, { "length": 16, "nonce": "c59282b26cc46a3f64c4f96f988b7becf299e64d74ea5d174327ce6e043ffdbd", - "payload": "AsWSgrJsxGo/ZMT5b5iLe+zymeZNdOpdF0Mnzm4EP/29tj+H/kM0RYeok/TQYj9ytATrwc7QzJjgFTgb8qddeAXD9xyVlgur/YvBxu66JLk+mn3xum/NTU4tgW/jPdtx8q/w" + "payload": "AsWSgrJsxGo/ZMT5b5iLe+zymeZNdOpdF0Mnzm4EP/295Ln8/B8OrC6ZeAaDcs9iZpmORItAsOAV6Eg7VFiaBBw0HJvpakEGHylX/KQTaMLUKLAoCWWnP9NcIGGIwaAeLEYH" }, { "length": 31, "nonce": "829f8e09d4ff7eda8329d644f651c604e52adf12f4d58e26ae85c89134a93dee", - "payload": "AoKfjgnU/37agynWRPZRxgTlKt8S9NWOJq6FyJE0qT3utwsuNYhjOYvkbsVp0Y7sIUGwjNUoOXaugHl0hGwk5/BniXjkmBLMj7yAwnmPArku1003tN3pT8OyiiXJamjqFOtW" + "payload": "AoKfjgnU/37agynWRPZRxgTlKt8S9NWOJq6FyJE0qT3uJx32nc1YClTcCwBQLknb6uZu9EKixIwFISyTrCPmVqoZGXwdUgvtqs2Y3R08laGLB4epJ9V9wzU2BcdjTNFEbK4N" }, { "length": 32, "nonce": "603e01ff6080e2d85edd38c40a87e939f406e01b805c0a8bda1db501ca23c63b", - "payload": "AmA+Af9ggOLYXt04xAqH6Tn0BuAbgFwKi9odtQHKI8Y7OK3veM1dwqc8jbMdjh6P0Ef1zyaxAiMnyWmW6stUzU6ZQ2FBILeuc7x9hTw/fgrK6mnpeB8GGZyktjPCfg4jBrBe" + "payload": "AmA+Af9ggOLYXt04xAqH6Tn0BuAbgFwKi9odtQHKI8Y7pSixoFXlvhyf7qM4ovbN8Kl1vRArNp60TZGFRyVJ9bWdpEwhQ6qyP09T5xYXKU8wdRqgGQ10zrnYlOkrhjZfMhqp" }, { "length": 33, "nonce": "d7c37b8e99c723616a572094952bb3e82562aa473e2dafdc6cff37cffa21195b", - "payload": "AtfDe46ZxyNhalcglJUrs+glYqpHPi2v3Gz/N8/6IRlbcqvZy7pwpmtlErzw0Bs9qI2/0ux5wv00AUtgFpLF6CU4cSMa7VMncojkM2bKHzJiM2tp6ZNdgxV9c0PLwwmyxFERG6fJiQDe2g6gTHq9co6IvBzrlx+u6Ehwzwh4g1q7pvk=" + "payload": "AtfDe46ZxyNhalcglJUrs+glYqpHPi2v3Gz/N8/6IRlbyxfn6xV4VeXQspoWtv7VeTS5LST9A6sSS4ZY60iBPksTZLCwimn7oJ6YwjAaS4XhTksgM9Fhk8W9I1wT5iXX8GzDoQytoNwWn2oTmPG8xM5CiwhToQbkID11BJDN+QtKHes=" }, { "length": 64, "nonce": "3508b7761c647e03af690a3d0264796891b366797408359d6e7dced38041e1f9", - "payload": "AjUIt3YcZH4Dr2kKPQJkeWiRs2Z5dAg1nW59ztOAQeH5ZH2OHo5+o1w8eN0I6ir7M/SakfKYKuO4YvIrPkdxRqJFhb5s64MR0UXQZom6+pX6hfhi6j0pIQkU8kwheab5lBT80Y3CgtkgVbaN5sDdXV/wcWfeCpef7TPfe/ec9a7AXSk=" + "payload": "AjUIt3YcZH4Dr2kKPQJkeWiRs2Z5dAg1nW59ztOAQeH5Etb2Urj27XQOCb2iykPijGhaNIEAU4STuVvTglW4aNzVLxIhFeUdb6rDia8L7eleUg0TF3Koc4HGxUviD7eDI7++occydY4M5jyCUNnJnipI5cVcamVw6Ynab/dqkvi7cHE=" }, { "length": 65, "nonce": "9cbb46d702345d74fc1e62fe7c8e98ea8d0663eac786aef2dad29ce442cb42f8", - "payload": "Apy7RtcCNF10/B5i/nyOmOqNBmPqx4au8trSnORCy0L4GdoeFS7DL8IVvdGJ52XUkrYa6cMjSYtzuygb1150znhcjxVmzuppId1yduQ1i98U1QW3q/mOPFj/Rc0i7Cq4z8tHotnnWgcCpYYslYVPAlXl0KI8HZn/VS6Zsr2jr2qnpOAba6gy20DuWuufTsdfsdMuFWy44VfoHZnUAZNsYp6QgA==" + "payload": "Apy7RtcCNF10/B5i/nyOmOqNBmPqx4au8trSnORCy0L4bKv0Q1mAB/k1o/YoKNOaI/xtKoMEwawMYe8JpxCIK9hX5780CEx1su+79PnkvjjE64r2tg1Wpd5BmRXNUrBZrrLuCSd3/JF8j2dsGHAODw+7Kdt9PEws7Y0KPyypNESjeU1pehtb9RtoFXjQhKucX3Nwo4dn+bjPksBl976SZkdYpg==" }, { "length": 255, "nonce": "e0ccd25f7e14cb8d44bc2711fecdb5a764f9ecac47f4b7b622bd1bf4ccf9bff3", - "payload": "AuDM0l9+FMuNRLwnEf7Ntadk+eysR/S3tiK9G/TM+b/z4bGbA2E+MRQgKBck+FUQ7s3mJPYpnzfiHPLYsOheeeRtFU54TgMmxgYHdD3XF3IJHiREUuZifnFwPNwd1Minlsi8mLnAHRzVE5VrRoBN9O6WNTE03odtAYBG9l5FjnvmuEcaNO1hhHh2QLH51Trt3nTUDbKhZeZNHKsf2HOTaCovO+gUsqqEliFKyBQyj2UGg37dUGLDH4/JkWikyBycxumxya3HnGLPnx92PINWZZyHUPa4Hn/uDvgyvQZIMUFOsmFWOJCZlfYRYV8DPEP00TVaTQvz7iCdeDUk3l4/XnILp9uvKvN2TwuoYowuxLEPm43/9EPiVdYnrSzJg7BH9aB/hvpgtq83VQ9ISIEP2g6X5qQ/wXwXSo3bmwEEiVHkkZA=" + "payload": "AuDM0l9+FMuNRLwnEf7Ntadk+eysR/S3tiK9G/TM+b/zSMVWyPbkrJM5LT0RoG3EOyw27VCBymYeou6nd2SsY/qbrYBD/gyC/sIMOWnK5yQs9gAdWF4Ps46Wnos3iAEiBxF1nIp7Yb7ih6J25FIzJA3Lj8fcZdI3NFEQPfCFQLtKL5uXpv9v9X7KIJynlz8PwUwg6oTkVXSpV2u5u9kjHwsspv6BEKQni8VjNjAL/M1nMU2ELGqfKhkCAD7A9SM997Q6F3fsV+J6Y0er5Htf/y77AnnGm39QjypgTvmWzzPui6shVvuNE1B/UaWt3+/NXnLMOY2hnO3X2dNdPBoCnn2alf20N08XA7njo9sBaJu5F0vV6VKxcQan8Mhcn26ema1pUqvEC2UC6hocuZr2LOo/7Vy03PYrsVEdMkKcwFUImnE=" }, { "length": 256, "nonce": "e9cada0b5fcba2a39654121ceccf8779326057e56aad0057a908fcad2b2cb86a", - "payload": "AunK2gtfy6KjllQSHOzPh3kyYFflaq0AV6kI/K0rLLhqDj0ZwlmrgNMKZ5RMBU6MxEjUiT9tp/Ud3tcAPACzZSOUmCdAR/UovjNNXqCyi+3S+NC4R+2GSz5idP0HaKBprZg7ThkcWzm3XgfQAsMY/ZBrglKLmSi0kzqzhKI66xjBWReAK6kwj6ZitwkiKgftHP+XHZxyFcvxBXXz/tf3k9YLg2I6bbNO27zzsdfREpLXS3AOUqLB7rc7p5sc0UWhzrrYcX1+aEUvRPeGfB8IQnEKtix7QvrIyto3LL57Nz8dHhd0EqKmDPubXIu6xNwRHLeePX4S85xyQQPX710MnjU4McNS5r4m3kL7M6o91/K3wWJBd/CvnTaxMtiHBiT7sL1FwJRTY/0EmhMMHgVuwPl1X+oV+apFGFfQIvhtZghkMAQ=" + "payload": "AunK2gtfy6KjllQSHOzPh3kyYFflaq0AV6kI/K0rLLhqehCOBen3+hr+WNgUaThElOFL73Ba/THw8+mTc/s5Rvlb2rr7fc7W+DH8jWg+R6bQ/N6F7e1tPloaEY1UXiHhNb+7zRa6YOnsURLFzZRvTIhrItbgzQwswf5soA4iRipFa7vZKRDe9I7tFu2pk3j6fFcdd2VvPMRLFGt3Mfa+e0QCnliagvaQS8Xlj3es8UEbQo9AXbw3kk4Yvfw6qKfJNIinUTGATaxauNY/3Wt+HGmAW+CPByhLNSydyFI5Erglm1EBPsqra8DdhIRTyjOS0rFxjrWEjXoYCv0rAAdvWwFj/akd+ZtmVhpiUyqa+WfenUpK3IgR32m+l3gXdZ+yXQRtnmHGnyLYj5faNLTdm2jHfverqpSuN7LaFGp9hlVqQcg=" }, { "length": 257, "nonce": "236ab2c2ca02af483d14421d1a7544d3d12b345a895379bde5e0d37632318990", - "payload": "AiNqssLKAq9IPRRCHRp1RNPRKzRaiVN5veXg03YyMYmQEmAYaFE6yYGlW3ebXH7XQWhy3lG37mTnW0kxG2yK2ontVr32GsviiBzUe2WmVrjzlX4Ow6f7rKRxVAFBbAXKOW5OW7gVVlZl28W2hc0wxAsGxwwm+Q8DlKZYu+27ho+1MpuRH/hBMOseJJ8H9qGyftC7rGMX/ZOXT3h2qzdhXS75hs2+8TugNaFcHP1Ogul2Glalx2ZuU99TZX6dIZ+QhDmJ+CiBN8G8rTKNLUZFZjO9IxBewWzEyhhEZtZQ0cPBV7ZI4HAG3ffxViP8b1APfSjFzcEAaGbVMJNCqSEC/vso9zDgV/atbhmafVU+B03MSd1VBFeFZZ1hM5yvoPIc01Lub+UR3jOIqidQJgWFpKlaSj1Xh/rgHmB51WVyWJEKI/h2Huj18IWe6lDSRa3fxQMV/lz7Gj4XeZhUDBWxt6jjDjIiOMfmh8sq3EFlwSGznags/n8LL67Pisof2GeHSYmR" + "payload": "AiNqssLKAq9IPRRCHRp1RNPRKzRaiVN5veXg03YyMYmQOtIrHMsOt7Fo5ftglNfE7a0dtOXP5p6O2eO/+5gZH4v80QBN4Z6lAMWZw8+Gpl3ZWgJ3i/1qHNrOu9AR/ceZnJ8S5dTuLuZRnAzHKSBtRidUNQRI/HQTVOtJSiv5v6H35b55cVmnN6rikgBwQ1fJKm8e+BJzISiY2n2qRtvffOASHEDrReJa85gId423WRyMhVsGgkiCW1u/P11f4t4bxdRo5Ia49HieiHfJWfJQ/FYqqf9RtY7DyRFrhPuNCt6oUTKnUJb71CMF3vu32xkDiByQ6in/WyxKxmMyWW9tKfJKaASQY4Dlm5HJfiuWIXs2JBrABXvEYSuRWCEORzWV3t4dIrmbfZaiZes9JGM9HGRCd0BvGxpGAHKW3OD1ms6v5ZnnMVkZNc5OUuioQPlFzoAkj7NCe2NsGZ+u6DrkgYKzfIgHwTep+iEKgMw8eWMYJuNyWPyCCJ/Zgqw8/9GL++jb" }, { "length": 300, "nonce": "64d384796bae1277fae95d440124e3e024f42154562ebb646731d9b00d74b826", - "payload": "AmTThHlrrhJ3+uldRAEk4+Ak9CFUVi67ZGcx2bANdLgm1qcXDcct3ycJH5ROPxX3DYK6qaiZyDFyrSoSD/9E+Qi8SdkzCVwyw7kxidaMsQWq64LFsDWJfGYrXr9LqWkPwlqrD30IjRB/TKytaSsJetyyZpxEoMsW+W/+DuZEVXv79gnWwkLeDVM7zvnyHL2pBCJzKU+Nxt+cWvqWbV7eDKzuX2xxSK4r2bBZZyWt0NQEAfAVl0R9+BaF8oBfCfv7MtIvj9fe8tkJYAmfLmYOiFGEDSY4/zBsY2eiSK4tpQKJcgYm5yLBSqQKtV0cSujGXCRCeNP2rMXn6SP3LB6jDiFX1JIrJiO6cC3lXBSXlCzGBXMLWwqkJ4Q5l343k9rvfk9iAA9S+vuPRDm2FmOIs+VdwtMLEFZny//PrQDRShR4mghrMXty5uZN2P0yjkIF+ItAg6CiWw+POK3bVbUol23b6jQ4oi8AnlzazBlvv8YdFjSBeBrnqmlEgO+mYUM3DZ9J" + "payload": "AmTThHlrrhJ3+uldRAEk4+Ak9CFUVi67ZGcx2bANdLgmeI4dAnYXaJD9aSCCRuAgQNyv61dupPRGs0n2Gq3jCrT2cQlwaEtIeDfShO/PWlfSx7G5b/Ihe8oYbDiKyxM4plHhOSJSCb9e5CwoDovAv/RnmVbFC4uHcU96CPFxCveRn/eU7AJ3t/2/qbzOAWutky1QOAN5IaEctTNRkVEwPccvG3LTFMCkBppqCud+wvaiWKl8emZuvYA8IGy3TKVRI7ZyfGmEu5/UoQHpBvvhXq16aWE3Mh4JbN4aX7NaHalpmpVsiNHx36LhXblhUmI+/imkpMZ8+pa6m32DzDRefJwLRNyUOzAl5ZcyDDDe4d1ok2xaYAAPpaX3wQ9iq3j3MqtFQ58wk102nsL9TDX0sktk5orjJNqx/ywjCjzw7efK8Unc9uODM+T2wMDlIztgrJ8povaP74x2qmO9Qyj0LBKFMRLS9Ulqn56YsrYnLa2GQbNqy2Z7JmfmJClOpM51BgZZ" }, { "length": 1000, "nonce": "6d4e314c39aeb7e42c44525a4417dc4cd08114294fe22a36160c50df3d5a4bed", - "payload": "Am1OMUw5rrfkLERSWkQX3EzQgRQpT+IqNhYMUN89Wkvt28ZIi31msLvSE9qxgoeYj1bTUhQaOtfk+Hpkd+9dCguNvcpo+iMlJss/NWCFxn5Asj5qtixuxinP7sizM7+1tO7ue/QXTZY6LGiEZnbF7m6smM4ZLcQoRFzb6Ju2D+rAEoyy23vLhlnxT1FXK3/OpWuPhFSjTP5cjc/s2P2U6XQOUW2Y39XRKO5payBFUzzQZCfLKSL81aG0PJ4e2Jr1wUZ2nkpE2Wi8g314mvsz7IPxGRUFcZkjEd7bfSLr/SlhWb9vj6xPVYYiORLKylCvy4oVmslrPuV3Oi56h7UrSe+a2oGtFrT5mJOSaAE/LTUutoIBE9dbROmkHcoxG8lstxB3uzPlm9P9IPHS+dO46wI9Uq94WqEZAFX4DCuVpIchGUHTJF/6f2F1W6RLbygr0c6EhF22pxTksR0FxRxYaOuD3LiBCvJl4+6ePbxbjQtBuTaF+wWg3pj0kmVOjp7D2Qg77Jl+uYo4DneQH3vdyVMKTxFBUvnRb5c6ZSQCqPTDFneRG4wfDPY0J4Qs5HudDZkuHWcbVE5/ZGbRVcaguugK2l8NgU/x29qiPpwRH+qpwI0eQYvg6NKFYUr96qEbjQb7VCyWcaWba1cZ4CNziBU7suR+o/wR5YQfRCt8OwrYYHyktdgik7sm57JYuK2sqeOhLs1R+srGGFAjajLXnIEbLjUMjqHBxrWc0NDGn6Ea49NeY3tKUtuFBISp2BTd0GOJ4sv40YQIWizbN/VnFE4X14TVaxXlPtPiO8mNyRsTYN5Rump/LqTCh0WkicAgfALc007Nb9um+Gln+hbscsD2QRbv/JjV0NsjRhe6GM3nm1DT5iD3oaFkl/GY3uRxr1TQiI4WXQ8SEA0yEhMJQcUDqvFpAarcdiijwjTYO+jNjUEGLZdDfF+v3xjZSr3gekYtEujDbEIKbjBR4uNBwh6/xRHU46ORozsQnFR6wa97udgICpmAThrTKa/iXhKfg8tWZyaSgO9ddmu0EsGJept6fSNB7tYdgk+nZQSRcNqt9h5ZvyI6EvcnMEBfdRTgfJ8byA+E0WU9G9tj2o+OqpoxWRMUSizh/KkDk1qrUiQHZRWmdbl5seEzXOA12YgXyA3Ajz6f7iljpdK17FJsCHnlkKiv2oszqzY1iEdzwpVHl8274Kt9arvVwNjFmlFZGd15LkEGgMt2QkQTv5PU0Ks9S7YK3sfJPm+EVQhnmeubJqjmQStq7PuUwE+/jPH8YQqHUaEl7G54HfuSs0St+U91Ia/6ZNGxWnldy3VRX0g4GGWp3l3nvJAKM/CUV9ITjSerLtkC9q2Fk7TYOGEgiQJxnINdn1XRinLmBWgkLBA85l4aIg+Zho7+C7d2S37m5JYphV+p5KJ3OYhSgNLisHSla5N3vYCwDCK6C8WOF2ZBCyY=" + "payload": "Am1OMUw5rrfkLERSWkQX3EzQgRQpT+IqNhYMUN89WkvtUP3x9kY37gdcuEoUKMddDbhF7LgDY4Gh9H5U6JXG/tKfL8ycxrWvHqejY99EWHZiMmw+DUqzJN041m8wdHUDe9spcMGKdgbcOSWK3G9+Qsa2Xc0Wb8pn6EizRim6pfdFKNlW+dISkhHvjaP0JAGjgbykxNUyHcvr+UQTaDfbE08nmm7pN0IBwzxp2PKw07059G45cBPDLYDQgaqJ/VSGEMH7AY8QvFYNrRqhgmtxYC33vUBzBEnHhF4Ygz+7dGFNaX3WmgHLMpn3kK8hIqRIQQMtAoJq6PtFbayusDWp3ciVnEQKzgHP4GOMu9kynbhlFm0pXaqumu0EPKRBY8ed6ZUsl3lGCbR/nHfZLlSg3pmPPfg8XX649b/PFpiUZHWkgGRJ0xkVxp1pDGyQla8XDMwsv5ASpKvP9PKX1K9br9MP+eZkYkhG8IkdcJk/rdezGo6OCnhYrXJs3sckjPWQprRE7mINwY3fxiF06fhYHOKtFTW+6NaHSOPHvwJUlhHRZViGflfTMtUksYTs1+72dqOHY8YeCftJMvfvt8t1dYiRSfu9Fnk9q28ciHK2crJq5up5iLjvOmyqfp3C95lRc/MCyhKsMJ/wstxFqGdW3Jj7cOEtvg43k5ZkwrCzCnxqhFWGQy3W6S0uukhOOoHESpGBgLE2B72rBaI9qBfu0w9cXBY8iQox0m3PBanx7KvCMZyz6RRy1e3G0rLz1wyDtX9WVOsiyDbXwfpK+mivViE4PM61MJhPdvPNyUEd3AKIu7o1DA7+Xd+EJeMKyE4heeU8CJTkGcrAcmoK+4Hhccme4wMPmGkkeUPx0LVe5PJDgHWceOhRDMQVwSBl3l2QXuUVkyS9yq3HD1pAwpW938xctXyhuzVtHkXrFUfBB3VxWQuj47sGRQw2029W+JgxeFFFToIJjXo6Jiujiu/gpGH/oAkIFEHWceDGm5J9M0QKDc3r+vb+bZSjDBszWns7fqLl7eID6qUisNjSZdBKkysVpvLH6wkwBY1qS1Be2mYz3IzwwPos5bb+weK67cXzK27Y4C4dz2ZlFX4KGvKrfUShLGx+S+gRoElRO5sFLoRqpxFu4lqFLMhyg8CPaG2vEeDMTu3jWFKFOV3xxu3Mw01Wp92CzSKtO//rqIzcwsol+b9i7Irl0FoWjPRQ2S/BclvVjMs8zJawENBU3oF27h1xMwCIokiy8aBKRCv6eupKZyfXh+f0oifZWMzUzA1wmEwkJUXkzdlgsYEKap4/W/iE2xhAnvzXjjAt1LTlRFe2aEQmmNnN2SZGeF1c1OWuGVjqHP7V5vMTJHJ36KfJNHP9g+hfhvmWXJu1byX+gSprZJOptMhDAFBy7B859PfZ/RHB85jJkr8pmA/dcXVIJL69Yju3FARzVG6PMi0mQUBVEwY=" }, { "length": 4096, "nonce": "ea2fc87b3ffe89ff97b7c34dba9ded0b72a9cda90eb5623708edce2cbcd96d39", - "payload_sha256": "75c77a17bae7cc7614bec3be25c7085b5797ddb287d0a399f3510930178203ad" + "payload_sha256": "912600738ccd168bfccd5e5241c492f07ced48a1fab1718c09aa2648af5c5936" }, { "length": 16385, "nonce": "ac23b1e608d8809557360341fad3fd434eb4fb7e3ad8b4adc57d32f04a4152dc", - "payload_sha256": "9ac981ee461bc2e0b73a988347c7fef7b1ef7ee977179c338c4678b4f00a501f" + "payload_sha256": "01ac3d8dbf0510498506d14ce199b7aa97bf17307aba331eab9d831109d409c1" }, { "length": 65408, "nonce": "69f405d2cf1a3ad0c5dd6c06fa841c0ab192cad58180a9bd961cd687e9db3aa8", - "payload_sha256": "68036cdce1f2774f630f925606e8e92cb3ef7320cdf4d16a1953a1d566ed981d" + "payload_sha256": "b4adb6b5c467a289e782953820c64b08ad9e5237e6e8337b66d9f671e46b38b9" } ], "peer_pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", "peer_secret": "d08057dd8ce33af2699b9a44549e2b6ef1ab8bd3c62c4f42bf129065b596d920", "proofs": [ { - "proof": "6b2100d00060dc7fac20a43e2777322d3a1ee5cfba4e38c200e7a8d7e96ec28b0a7c9dcd3520462bb896959d9f2fc1a3fce83854fc05c49b777cb32697902066", + "proof": "dec5815aa22f5cb32b99f5aaf716b6581dfce93127bf42c10a1b086fcfd5627a762deed000e87e5ab250b883c7bd77539edb5599735e5ee43853c8e17d4ab3b4", "timestamp": 0 }, { - "proof": "9efc87738e2acf121210f9220043e5d180b90a0478200a80da1847bf31f28abe691d007706b916651aaa4c7d21814bc1261bbcb64d25d3520791e2cc5a61ccba", + "proof": "a2f932d1eb41aecd0148aacc0efa7a0c9544d1b711e08727f9b86933f696ad9dff5e7f0089a233f40dd817cd763e3f924e952a6857dbfdf3084ebbf92aa44bff", "timestamp": 1700000000 }, { - "proof": "9db62dc6acff746806b6d3fca11f47039afa19ea90f85a2b7df5391dfe311f851706db0b9d6b213025fa4324573e74a49ee614f67918db2fdce4d96707038e3f", + "proof": "8562533f33b3ed70046dc7430442bdbe18339557142652ef7264531be5c829a0f92d73bd307a64b876cfe312365cd6832329c8fbabb285b8e7bc6151f7bdd1fa", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "0e4bc123327e0075c1c14edbb87883c6c5286e8b91511cea28c0c0e09f44ac07" + "transport_pubkey": "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17\",\"share_index\":3,\"verifying_share\":\"03028300300bbe4b483c81d1d84f2555a633516a806aea54ef22e87b383d1bc892\",\"proof_signature\":\"66a806fc73da48cf9e9f0fef73ac93bcd796b510cfcb29f1f39c16bf79c145cba33ad9dbf9d90d6734e77a9f2aa0bb4361b25c8d8673305edc24f2b88cb29288\",\"timestamp\":1791465431,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", - "created_at": 1791465427, - "id": "7520adc34a99dec1f91924b2af2e57af31e1da49ac8609816b6f76fc4bb93ea0", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a\",\"share_index\":3,\"verifying_share\":\"020c9673e17005783e1374f60be641ebe5fdf3883a009c49b8aa337fd9e3c15457\",\"proof_signature\":\"c63f181cd976fd47e0d20ca09c24e2602b80abd746558af0616d4cd0b5ebe15022864d545c9732fa89b7d09c5af3e95e58218d3611b006d7e4ee137da8644b1c\",\"timestamp\":1791467349,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-0\"}", + "created_at": 1791467345, + "id": "be12bd30086deb7113f34a07c2d857e836bcd20fb3cda1581c2c84175980563a", "kind": 24242, - "pubkey": "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57", - "sig": "35ff262f6b568e9b22427e1b7eac49cd8e8de588743cfa05185537c747ef5184f3bb0a195c985d30cdada518ccf27de9071ce2ddd843315b2e4bafa12f6581a6", + "pubkey": "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb", + "sig": "36d68b59394400bc0ddf9ec571b8395b8d77f41e954bdf2f8e74a142b2266aa71ea5d100113f36bbd0b2919f7a746a26b2deaa675afeb3e5dc309c8670381d50", "tags": [ [ "g", - "dc4883a4d55200e347d3ab7dfbf34d6f16a832026ea95e4797acf27576c15b17" + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" ], [ "t", @@ -361,27 +361,27 @@ ], [ "p", - "357fb06973fe9f1aab420064cae67d4a08bc94b9b14c277a2bb4dfa78c3ca71c" + "c8105cdfb67c25d7c16cfc8766b6affc2d8a5a9acf149e3abbce80385d7f1d90" ], [ "p", - "faaa349bdfbd56b3aa3c4c75bd6e0881b55e62f6cc060c8f47e945670976d05d" + "9abc59a7bd6951a409d383d0d59dfcd8185b45b2e07b06dfab536de847397f82" ] ] }, "events": [ { "event": { - "content": "Akyp5ryiFojxqXRpZy0vGR8finAx0CByQtKr1l1HqA0jX5BgZ3MB0U3yjbGG7cDOivcL71bIcvAQkPvRQ5PcvfcQiB3Usw120Zzj+xYu60ooTkaY4Dq2I87mfXhlyUKhztQbqHsE9dlk20luH3PvaUYOw1RsHQrsjD4q6wmOdGViPnsKyEVZ6GWVKO+miFDKptJ28N8AUmLQcZTTeDCzh5XS5huYQ5J3DQvYNZh7u0XIyWehpUq1MJHrgCOjtI0vHy53", - "created_at": 1791465428, - "id": "88823ead71ec30efc22b8843b2e27ded2feac26b48da0ac503548369877bc8e0", + "content": "AqVtsh/7Hrq8ZWsPTvHvOcNaWcFQI6qZ0IWe4xOQDUDZ/MJwiXE9660lhdwC72F8rsiGf5e7JrEdLkcUcVHg4wd0sRbLVkj6IiRmvHy5zjex/Ga0V3qk8DWrlWXYqDIq4VensOXVMCdIrZZ5UJoOGQN1Ez/WpB319Hrwe1qfoUwae7W/122ClmHYw+eHmP9pgnLp+M7HFsSh1lRW48KV7fzc5z25MBPPMCX+OGfLwYXyqWzYVRKfARoFD+jwY+ngoQMj", + "created_at": 1791467347, + "id": "ad87e01b8ba7465fb40b31ad9322393ad62b373be849a3170fa6970b432c7bb1", "kind": 24242, "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", - "sig": "d6a9aae71c7f495e49d0f9711a9f6700f8e3d9e2312f82ee0b03e608d00aa05d77a30bca2f26db80b899706c9821805c8a239a00ced7a7778ad2f9e4d3d19733", + "sig": "352ac4b89942eb832897afed46a8b2063c563875b476a156a05851b17c970cfe87669636904d6ba0b399194fbade55607368ab584374e80f9fec614880c2202c", "tags": [ [ "p", - "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" ], [ "t", @@ -389,20 +389,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467349}" }, { "event": { - "content": "AvPa95m9CTMzMDYpZVp7uxM2cnDyXmXmbt1obw1uCv4CokR7J4bUjTVo5pH+qZQXIPyrJmrOlnPRmPwb0fIB5IIjKM3zLza9IJ5ka+cKVh46h1uL0yrT97UfR+SDgXHj5TnItbbGq/cF/L/Y22cKxcet1DIdHCQD9a5G2fa8sTuFwj42dFd/V3QNbH96HJCCN7eJHSfqfDgl+BDmu3r5xG4t2objPi2ISbQsB+M6xp8GNltH3MaDKBs/GTgYEVGY5Vrj", - "created_at": 1791465431, - "id": "46a5f8fc26d67ff371b7a8891d7888980c9374b7582046992df03daa8cce8264", + "content": "AnfVTk3iyOi/mWb6xgUM9IPwduRlK4e0w4KApgyvNleWwz+wsOpVLhbROkX/zKPd6x0pI8OVKlA7tGneYCWV4OJb+Kf0/HHcE0SPdtnEh1itQPB5TLv3pvf5RW83V6OOkPXfM6tylNxsLwde/hqrgp65UwnIAt/env311/sTHq0xDbsni3lMyrliZDr1FXmEHs1HmZnqCjw/k9Ouqt+S8uCKnlTRyeVQWq88TTEtcHsJlNHoCTLxu/QQHjU5eHbw2myD", + "created_at": 1791467345, + "id": "7f050993f3a644e54d7773a015f7926481cf6da28ae328692189b179ebdcd00b", "kind": 24242, "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", - "sig": "85076549c7707d7bfd4cf9ac787a37a5970bb050d17f9b89d64117ded19d40de9550dcce795539bad7a4c5a30788bb12aa3448d682d9f72dac8d2294da415813", + "sig": "13be406aa07c0d51a5e9785eadb2764c3a2d4f1f80ab089b56f798b22950bcaf165671856fb6fb359c77acf63bcd0e8ce8ea8f9bcdecf9ff6162aefe96503b08", "tags": [ [ "p", - "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" ], [ "t", @@ -410,7 +410,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"b15598b5986ed1a942702c5736e8131ad209a9af3e8999bce6b2f677ffcd6703\",\"timestamp\":1791465431}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"469466d6b702f15fa587a680ec6058051f89a2dcdaecb3cf9dff1a63b72d37b2\",\"timestamp\":1791467349}" } ], "index": 3, @@ -418,120 +418,120 @@ { "length": 1, "nonce": "9e2a77c6d673d6d7bf4867ae2e21a690e909a969862da7cf69f7c1ebd21557f5", - "payload": "Ap4qd8bWc9bXv0hnri4hppDpCalphi2nz2n3wevSFVf142WT+fkO35qb7Lbf0lTMs39XFlBklP4dq1vzVRa51f4E06edG8/Abopea4izMK6uPHS1tHRT44lzFhz/Kq3BSptX" + "payload": "Ap4qd8bWc9bXv0hnri4hppDpCalphi2nz2n3wevSFVf1yQtgBfRQmVNhI6AWW1dVyEVxiYPOdllaAHVWWVOiLpOtEW5Uo1uG88Xljf79cYoZN7NV532qD4uVs4Hb13WBf1Dc" }, { "length": 16, "nonce": "535994757130a18b2a32a9cf97f5e0547eaa34085f3ad74ada82cd2f636d932d", - "payload": "AlNZlHVxMKGLKjKpz5f14FR+qjQIXzrXStqCzS9jbZMtQ5SYb1PfO2m2/a5oB/+KuRBbFsjEf8mczSPJ0XPNN/2sgyHHEx6VSrzTKhQPm1HOf9YV4Y9lriq9ef0N7/svNxGG" + "payload": "AlNZlHVxMKGLKjKpz5f14FR+qjQIXzrXStqCzS9jbZMteYLdf7l9Tdg6K2boL6o9kzotx+qnW5e9ZRDU8IEDCh9fnFLkgaK+O4XDslEwvMYH6J5F6w15fgQHo6JQ2rv6s8Lt" }, { "length": 31, "nonce": "05bb75660c644972b205a0483897cb145ffdaf56ca87d91a24895897172fb6f9", - "payload": "AgW7dWYMZElysgWgSDiXyxRf/a9WyofZGiSJWJcXL7b5+Tngt/9gz8c8O6KfD+Ry5a2lAwxqJHcPbPr0i6EAj38ovWzyjBkl6ISOqafY35izJ4isMuc1M5xEVUe+sNKo1lhr" + "payload": "AgW7dWYMZElysgWgSDiXyxRf/a9WyofZGiSJWJcXL7b5gh+p27ZyNB8SMU6BDgkrDd+wnK3uc//Ucg9agviJ1uRZ7Og7MxqlOuFrDgG/ZVxQbtN4PQv0KAqoaOJDGUZgHUXM" }, { "length": 32, "nonce": "3fd542f4df8fde9aceebe044cf9d3b1bd856c4f5e41e3208de1e538cdb7db141", - "payload": "Aj/VQvTfj96azuvgRM+dOxvYVsT15B4yCN4eU4zbfbFBjMQETLT4dKIXce+LMDzjXhM646d1P7wV4uo+5sNBiOZVEADR+2wLysoC9eg+iNlFkm45Ox7qe81HkINM7FHhg7zh" + "payload": "Aj/VQvTfj96azuvgRM+dOxvYVsT15B4yCN4eU4zbfbFBpI8w7kowsYdk4bjkXAOOhfsNpJLy/RT+5P0EK9WPftYIp0AHCHavSIyvu1ccl7R3G4lWtoOMeN+wOxHo7EA5tBo9" }, { "length": 33, "nonce": "43522a905753c2e7b53d5cfa5d24b2b26ad302b93c728673c7cadca254cfc923", - "payload": "AkNSKpBXU8LntT1c+l0ksrJq0wK5PHKGc8fK3KJUz8kjNUp1OaslQ2dWtIgao9g5CneUiuedw20rxRZJR7A9ibB012bd17Fv0uFTacqTW+KscbfvOTTsiTHdBLNdKbVjK/LTmA8ecH2/kXMA0jFVw66CQrriDxzULxlKb1n9yS0b31M=" + "payload": "AkNSKpBXU8LntT1c+l0ksrJq0wK5PHKGc8fK3KJUz8kjJYdGLCIcIQIcN0w4tDAESc2W2FrOTijn2xUItyKQcayxjLULRlr8GkiL7L6xBeIySLdp34tfLF971SlGLvA1tw439gh4b/sD27Fhrq3roVjHHjg8A3qFWmTwmg44IV0LWrE=" }, { "length": 64, "nonce": "87ee9efce73ded10d6eba1295eb83799494fcace22215dd7b3ca39e42663b501", - "payload": "AofunvznPe0Q1uuhKV64N5lJT8rOIiFd17PKOeQmY7UB0iw2pstU8PTC/k8s3xI/UZowM93+75DqRl1YC1xyB1sL8GsRvaOPqCoMyrqsPciKYYDw+gd4sdgQqtCLtgI2rGzaIik2xnH62DPsB7PwVwI5TO4dcIJBIqqiyZo2kvrfx4o=" + "payload": "AofunvznPe0Q1uuhKV64N5lJT8rOIiFd17PKOeQmY7UBEzki5Y1xyTKO8r1xjGaMhhdHWeKnnb8AfpZdDcqrpv52DC+ZgG6UCa0zTySW6IwLvtCuj+/4sMay6XKi/0SvGuKET83drHerc2HDiY5elUXIQUAvxQLaTFwichANS/tXOcg=" }, { "length": 65, "nonce": "e682c259fb54aefcf20272bef0677b1a0393c2b5ace572e2f6e2d27c5b3100a3", - "payload": "AuaCwln7VK788gJyvvBnexoDk8K1rOVy4vbi0nxbMQCjfKuA6XnSkNoeSDW+EAzx8oTWYb0Y1m9QR76/DCT/id+JThR6CvR/ti7emjms3tYifD1bURfyx1QzJHk2kTJY8Zctv+zgUVgdlAtKcefwUIljhilSAwlwMbW4Opu3UPO3cQw0Op4/PTjDEV3oGdoLr9VkOGxfw489/JeWcQPYYq4Ydg==" + "payload": "AuaCwln7VK788gJyvvBnexoDk8K1rOVy4vbi0nxbMQCjmnwjZaFeN/iPuATmc3iqf9L2QzPXkre6eB0zuuklyqha1ncAedh8N7JP9q7Z7fij7f5d0T0uBzOJs9tcX70F30BGgPIOi6dBiDJ32/l/yiR1cz3unJzm3hgqt5srQUGgkf8dCMiV0oIGONd5udniVB/JWEmdCiFrd42QQ9QCkCWxmQ==" }, { "length": 255, "nonce": "e88ccdff56a18bb1f04c786a1764e06a4626cf4e5f73aa7b3f8df409df1823ac", - "payload": "AuiMzf9WoYux8Ex4ahdk4GpGJs9OX3Oqez+N9AnfGCOsw0jAm04N1zQn5qQmIcIZhm4+7JP8xxffTh5B1aLob+1lD5O08qpOlHCwn7NUJR0Qk91ny+p0GO5zdLRydLonVvgTmq/dur38icRg9lj4YHOsofsUEYBbfmr/PrIo275zSDNQt6l5tgaWH//A3dpC5gx33+0TJ7VXavybMD3Q3kOfXVmMz8UicMS9qxgrM0nCMKnlG2pU9GYyP82qgALmVswDJGDNmDJQqqf4oD0J7n9PSjZTikoIz4NSPB7RK4Fd6kDWa0pcxJtFnBgFrluA0GjjZF3dyPMLNl3RZsFrTu3y1CsYDhcjtNCQwFGW29Ki/cv/0IGtzfDBrCwTWg7z0Jy5BpfpEPC6+y9gXFoDaL7Yx9uRyT7UQbFbYra1L+ydKGk=" + "payload": "AuiMzf9WoYux8Ex4ahdk4GpGJs9OX3Oqez+N9AnfGCOszQOc7laOMB5V0uYpmwb9Qxaw7+w8VTyl3r3ZkupA7iEYgRjHz6vMpNfamMxo2WC1CtJkBrXZKJ6KCJ1vN7E3Jl4ci1m/w62CgSO/A/XBw/FlfsjCB1s3HxTX3dOy2mp7ICp9+Kg9W+VbK95alpVuypZoe8+xtreduK937Y+mmr6ocW06yBoYL6EP4T4ehk0qIWOuO/wu9yA0jPUERMnTuJPPWCPIkgNYme6cPx1Q9sUpPUBrzILFHhunuuMbnHld7l1m+mNa1fs1ifnNfsxktXaMsnl0cxJYcbFKDwADZFQnn67okcy8TQdWLoWgnaVzrbtaMeMPExhUgYpRwiiijojV+InyOTywY9TTlKUuQKjOE/4vOqNLWpGJQhW5u2Agnd8=" }, { "length": 256, "nonce": "e80e6934561a5bca256951d0be90f6f137b4c102b042f59b65c476ff4df1d503", - "payload": "AugOaTRWGlvKJWlR0L6Q9vE3tMECsEL1m2XEdv9N8dUDW5QmdW29j9HmU5hEinKnakkNfBSJc2OAvixd/XyDUffjTfKosru88UvGUUr93DgNCRn+9JE8Tn444CDXU/6tFvJCNlF8AN6kLPNpuROFvInLDFS5yUAdfINB1iIGDlaUfrJogdXI36lLm91VivhYL7qyoap02dELYM7rWHW+ljm3UNkeJR4kr3qyGxRtuEuR+V2t98aMiBCt//auPd236D+npZxtasgQUNi2ZO7TG82rI+MRs2G7C7KfSYrlLob/uI4EfJNL68eQD3h/2a5QUWiMnehy9MA+0jgF/zk04syOZrkZLRUIPfxDO+fGGBVBRKbhlGQd/VdO5Ma6YmJG0REibHm2drFu801or6x/KbPqdo1NoGvfxs6/Zw5cEZEvoX8=" + "payload": "AugOaTRWGlvKJWlR0L6Q9vE3tMECsEL1m2XEdv9N8dUDMJEsxje/Q/eG3HelDrsK0O7Qvj2s1rG2jwFdpR1ydX/rMz1nUc8q4zc56KErmuIB713sydVWHQvWmJR4CuEHsD+cflH8A7V9i4td+rVPgfOAHwSGFaGQX2/2HzuOyYzy8TlpOpgrfxe0MCu3OTjsJXqdL+p/QificXI62CGmgCPNKY9hwqmMla+ArGQmFtCmvRgEXGfVZwBPQ3zcsyKWKFS/iA3wE0PzfecCai3ej7eUord5rrRbTD+xaXn7pP3anayuiVYy5wRYna7lVIYoLpOKj0UJ/o+QJGXyeB3Dr7ZzC+qYV2egrBDVOmEFE7mZcHfRr60FmyFV7m9MBxUg1Tky1xx/DDrHXhTMHZgqWBgV8WA1hmgQ4Ue942bgGf+xcvA=" }, { "length": 257, "nonce": "e3205bdb7ac94d53dd1f4d54825bb913de6f8ae15d5aa85affcadb6c9b8ca227", - "payload": "AuMgW9t6yU1T3R9NVIJbuRPeb4rhXVqoWv/K22ybjKIn7vGnsQVmZCuCDQZpJLRAtcoU0J8Dg7KOvUWUuThdi36aQrUSQFUF6xo3hpL4XDYHfPmfd1RSuotcxZHNwdNbwlUcom3+x6J4Bzr7za4qnEU4XPKgXSqa+0bYzKn9Qgd3NLahhvHxizdXZGXidYW+hjbzJb+pO1jEtau+BH0mFVRXywUY7vZx/jqSTosH8xIvGAHSIb7nEopKHy/Fs3+6vzvThrq/ycJ2EY2vA0BxugJK8n41C04DRug3N8jb6vvEFAY9//U4BukFUOZRxv/SsIntKg2UwBmz7j8RKc1BbXtxtz/NLEvJDtl1IFE+rj5ynrGzhPdz0oppil1/ZI8abhGN22BRm3P1ZIFD8EE/pUrxp3o2jx3Pf3BeIZGXprwJQwYAJHTRl+4hfpthrsiR29Nrcvtiw5jdAyn6orJCw9Js3Q6LFkBWFq8iTwMpUPDL1glGtKdPSzNPM1Th6eNFFFWQ" + "payload": "AuMgW9t6yU1T3R9NVIJbuRPeb4rhXVqoWv/K22ybjKIn4O75Z+EEbFvgqAwCOkuNY0XfW22WY1RyMo9yjGy/7wKkJrgNvkObo01yZ8lpudkEScYiBwMLi3VCq0dkp+nCXBBgJOjbf2NaErsuAefIowi6dZ9tTmZAHrt33pakizbewJiQ6byeP5wPzkLE1RlqvkO2g1rTIq1wP7rJdAJvvyMjjcv0YCm24ZWt6dRxgmuXNs3O6pYpvgnPWuYx/q5VUuzupSFp6jFObIwdHwuAmAUjJDnf5uxA9+NGSwjTNJg6OYU0165tbWPycn0rMeS/em4mbzb8mzLY/tK9GRnd1k5YPkKGCOYF9PYz6u5npoGDVszkTCBF4Q1NH7qxDJwApF7bfv4G2R4l59cWrh0vucePcmI/NS4uyjKD0bsjXqbx11L3jLV/7nTdi8ly7Bc629AZRSOeH+8JvbjKPhsxc9XT4V4vF8eFqUmsdjWVVk4LxHjrwzeEx/vHYqnsqd0yGF1F" }, { "length": 300, "nonce": "e479da7089c604647c0b3e9ec3d6e5d04fb3750c380bdbd53846fd0940f42bdb", - "payload": "AuR52nCJxgRkfAs+nsPW5dBPs3UMOAvb1ThG/QlA9Cvb7h7YKna0eZtLU5zJEhPJMHD9QB9XQoKkNga1L3j23KbWjgIQ6LD8twQ36nLeuYqinuABj8ZMaNhPZkXtsSEJBnjJkSuxTAirS7A9iiP3wrL5YTAqtjQ14kNrfR75/AyX+IDntKIZr0PfBUwjWOCvyZExHKU2SYv69zn0k52J4dK6Q2tsOeWGmlUq3SEt+iXiqab+5DyeYugk48RvpCU/V3RMXLEr3ldX4F/JCM6GeI3ZoLyLsVEdSqgysukqL5Ma17xv/vAYCBEuk6CBr0u0SGb8W16dNSjx77OlgEhR4Oqqiy/XSQ4duYkANJu0aAGiwy+zzwByrhTxW9yyP8TKSAWUCespta7RACCf3I3tZAv/A9hXFZ5PCi414GpEVomBgox8ODI2gIBYIjOWhK7kCG1okIxoqVlMXqI4yBCItC2LR9E6ClYbRGpOhPMHw8VztPKwwsPctW4V365mbi3uN19Z" + "payload": "AuR52nCJxgRkfAs+nsPW5dBPs3UMOAvb1ThG/QlA9Cvbb6ieDr/BM0+Md3jB6yL6ek9MggGFieo4BMWgOQjAN7PwSYmqjp7lLlp0eERMxvH2zH+cbBXu7P+aKOgxIDz+n0L4IUmRCSarVQ+P6b8pXoRuW1IG5cT/xpKBtiXM+h4IJg40DDD/x0Jd5zoUDXsWNmwN2NbZnlduEshiuFMGTtkA+o8ZnrWqIg2fvDAwuXOvnn2jgFIVc/Ez4PXV0JaqaSBKpuP8hmMnAPqypIpiaTqneO0xVJQFmxpDV2T1e8fxwe8cqYrfIqE8v7m1UpyaZGttlbAQhJD+i30zl1BG4GwOR0wywDzkcP/UGPqmUZB9KvXAmjb2SitIVIctGTqyuzR+RPb+I3FyYKqVoZ4A+gLqwwkTNo0ClefBP4tjsQbxZs25yi7FW5p9FlD9tHbvl4xGF9DlTKsS792J7GV0cOcS42Y6GBM3dCXWgDS6iiCgYr0rKiUZtrb3CxU+us7YsuTj" }, { "length": 1000, "nonce": "e36590d3c71ea90286c92d96719b2378965d70c6e9ae99b4f9f24d62e25db510", - "payload": "AuNlkNPHHqkChsktlnGbI3iWXXDG6a6ZtPnyTWLiXbUQAkrmNW+lAIxbQTXTaCNWCqnvGyCqcveQBP86SxZNR28Sn+MaVf41S7VGExbgWErUbYzGILQUfzdTPV/8t/eTuEYkje8QyQzf13PZQiwWAwIk9npTx2ZelV6KWqnsVZ7H9FE1vVqI7nEMZPNjPa6pYKMeCvs4M3ITadPXQGUNPT4KxM2rLsYQtTN1CXgjkokRpKpLSCbMtgh0D9tfnN9iUom2jDxeuWgDJprCWhKyGOEExIqlvmvbG5ELkFuwe8WKHQizkfiZkoeSNeCRHorcZlliiFoKTb2g2AfIwL8i2xDZ5CruM9FnXPZdVigspCXpXikF9JciJHyPmWR6wQFKHp47BXK9vL8NHmev6mKwwYNdADY8FfzmeywvMgPqiajvVJ2/euUKuSfaHv6/4Rgt2h053ylKQ6KlXEiAonsoddPFiMLuVk0vDe4Cyuw85YIl4hiW4BO1P6EfKcJEehXic5H/l/jBX016L8PrM8cZtsWuS3/WyamFiOCOTyYSHBIZY7VUWnWi8m+t21gREreUhRejU3u4wtiAjZ0Esse2SgiiugFw4Pbns6uqyhpQX0iq6ow96QOo8+ywZcL7s94DdqehY9rnyQqlsrfT1PHGBBAyvKH1poyNzPGZ9tZ1gSK3OVaOkVNBceJKpXaeBe0KBUozLAziYOjDGMWPSpfcRWQk/qgem51Tx0u4mXiNY9rESJXZ3eDu2HVi8LEuHEKt8rEOpxnEDrq7A4fAcUF439g9C7RsZK+EHmblqAacdmZjCvgVLEDs3YS1a7si7SWK6ZlQMN7u8ybs2zHvOIpURZsv8C7tvB4yI3nY5mEaElYZW+3m0kIAJl1G1WN+9c4o0ywSlUBOKf+pDiZOSaqX28bdSSeepNwXXM+HnKJHDr/4TBrS+WPDs1dPRXanjxPvPTb6nFfK9LvL+ltQwyRz4YdhwAY5TuLTX8SxTiRrFXOBxKDDwLrGEG3/9WtAdxJ5Q9A0mF4qFGxu/eAFpmvNEbEV3FlQN37D9NaoEYrcRwNA1UyWvI8LiaJkSP0qFF0T7LepOf3zizv0G2MCAo5S+fvMmhnOaMoQpcCAE7JtZbyOYXYZvfFZQ2fVFv+qSAaQivcr3mgJJhImNaaeELKkAe5GtPFqBD4MjOiMSX8/Wz1odcEe12tNZmjCBo3vV55VQyF3FBBqlm9bxMyRDJz/PrCIgu24M1FBjZhkkC29KyExDH61NmtY50Ggt+BKMwOm+3n6cZA6y03FgWGp4HYoZ9FZZwKSaMqpAvIbLB5BBtcrwuh6bOWgh/AJL0J1aErAGdy204z4SgiwgxqaRehZrI6MMwkxkY4ZXsFwpHXraeMGmTps5c+OdsyMQOIcnxQSn2yckF6NZIpjNbc2YENuKGT9hOf7QfeS/Wq85vLMHYr511U=" + "payload": "AuNlkNPHHqkChsktlnGbI3iWXXDG6a6ZtPnyTWLiXbUQ/byU9HHJjPwROquRSlhiiuE8nr6lduX0LnZ2NfEntePRrtCd8qxAjIwaLeidMfwa8kbbdAOS0ExEEboEe0RjWFxejgRVu2zjWbUd3RhBfaQbqqtR9H0VHlg2IyA/M+skRJXsAWAgI0L1YUq/K6ZXyRDZmZp+RRcMg3Mwrn46a+CCYwFO75miTC4GEP6wBsjdmcybXtrl9ZYjk7pxD4xGifY9zzGbNzurNW7Et6FOICLfHyUXN/Ns4nYisoc+hywoEWG3NIXfuydpeNWFosuKRUTOuKq9tzhsrH66xWPCSSc3GBnsT6CwhLIGhsIz3o/hCh3jeOAYBuG2traK/1Ku+I8yNOwAyrsnGcAHxUJn4g+usJ3YsVKivTkIhMt2ZRPb4JnyVVqirAa7L3v+HR13EG5s6Z5GLks4Tk9yeGmAqhP+cykrjlggrjktc5fT0D7QBy28V8B1kglnNGZP5oO/w+dOH3H/dU5wainGO59WoeTbeoT4ZEU2STPMXAk9Rb4BW8SQ8m7lYd8l2SpV85r0Era8mOjaghxbqFdJ4FXjJGZAanB/KQqYMp9Ec6F9SF5iVeYq0g4kU/TeR0/WbbI6znLXJajr0zBZ56C1kz2/xQA/fwC/yH87/3mG6X4TxU2E1eujWlnYJpPJd8U+kxLv+dtAk2XAAnrgNOJHp7uHWccQ8VaYlEFBrQ/iMqrQvvrWbefaPGdaXHjciii9gO0Lt3H+i7k1u1RDeCF8bF/MxLD9GTlaDzqEJb/cP0chvTZEnmY3s+AfxM6X4W/XfATrfDWsIxN9EEZfMAdVJfoaTBXceFhb/vvPHlJ544DnlSqGpJndKrHuBjXH4XA7CD4ws0egOinn5jEkBS1mF2MTAYnAhz1QeO+f2nqvJCrGg/vTfStvUdVSXksTLFB2MueOz93c9j2d9IYVGIfAjfCoR0MpwkoE/UQ3UH4umLl1aiL7w/pqVW4qo8oTxzMpZJ2umgU3BvBsVUhzw2nzZv5gloYQHiQhhQPIepCZ9Q4fOJlA3pyaVLpsE6dn2S+rL9JXADKIt9ZyhGpoNbMyDjVSmgjb46Ne98SJLewR7A6MWHVL4FPfLxv20wL4kNxosgHRirSB/2SFLh8JfEjPTO1W6i//JgQXvaawZykKFIa3VCTqfo8myNKM9ueogJqwBb0gJrIJUo5ypWwtsyblb0XF96xstRnAWuz9IPuPWQedj8/QeHxZENCFnWIcWzoWr9asu7VkfougvPR9v6SX75V/HodMQAkO9b8vnSVAUqwlA/0e/8lMlspKbEMWuwrXNSoj/Ptx2AnLTydM6R7J6PqZb1YFH3oZZbzajzLL10rYf6ESHX9E0yEHcy2AdDpzV5vdqd7i0dRQFvCy8/6fL+ugCHz9OXlF8pdV/CX0QawZp2hiZag=" }, { "length": 4096, "nonce": "e28612b2595f35b756f3a0bafb793bd9ef121f2bc1f1c43c24b4f245bd66e485", - "payload_sha256": "b7ea91415ec17286c160bd289e133f69ec85f8467c797b59c7d1bd34c96600a8" + "payload_sha256": "b69ad12ece73d3c1e92cd9d10033c5bc62cea87db6aecebe4a066dcf13dbdd23" }, { "length": 16385, "nonce": "b273d218fae37ce1595891ad54d84ce94d2b17142cfc030687a01adac3badec5", - "payload_sha256": "904b3e8b574f5567178e45e4afa32c461bdf6d836d0b4ca2831643f04b2f2092" + "payload_sha256": "56960d164f92c9851aaa3a72de10aeb9c5a0dda400bad10ceb5fa16c645ecf7a" }, { "length": 65408, "nonce": "8b0e611b7bccf9a3bdf9d25bfe5423a8cc97fc6518ced6db38a766e4b8070bc4", - "payload_sha256": "e87c16c1004c327079d8977ccd119be3f92b14e765d898811505b55caa356893" + "payload_sha256": "8aa9e1d5a32510a67ccd53377d20301d685a9edf6d9512bdd293035ad8e6ac38" } ], "peer_pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", "peer_secret": "fba71ed001d0e1906f118958c3dfce27ab9d4967b127aeff8fb8643b81795d57", "proofs": [ { - "proof": "217f3ef8a18f2711edc1834433502ec96effc28592f5d6e67d131bc95f18813a96189a20d3c6175797e2a23ae98f690804080fd7e777104eadf3bb1a66f979ba", + "proof": "53ce13dca0534b7980ff0291bad44ed03d60922299e5f761610e3697ec7bf699eadeab93f0ceb3847873c53931db2ee7f769defa8765ef294d62012879cccf7b", "timestamp": 0 }, { - "proof": "d07054d22047dde3344576223298c5dcf26088cfb827c8925fcf0c2ee7681c2fe503d9a51d37c98d64cd4975b31c3fdc5335cbe106da24197c282ef0b957b1fe", + "proof": "5573b0ab66686edc2c92bc657327e7ee1d8e357f4004fc4cd0ee3424b532d1934763a031397bca7dcd8b76129896e8ba30451ccfef18ca8cdd1b3e6a34d9e08d", "timestamp": 1700000000 }, { - "proof": "50bb382a34b7b8d74f9fd41f87ceb3a5ea1162f839518e33ce6ed74b2dc0be96a2690fb10c481d946e6fa2e6fed6b4164bcb1c3c62b76417e60de8c849b0b9f3", + "proof": "a57eab79a91b8b5773f89fdb8983cbadffaf9ce1b72fc73a29effc722afe8e0b86d6d771d3691702c077df2ae19122cf1a46d52f4edd81a8421428c0156868d6", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "56ed5be562cc2ccc498887bc687902dace5ef82961a6801cb3a949e729059c57" + "transport_pubkey": "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" } ], "min_signers": 2 }, { - "group_key": "03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4", + "group_key": "03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc", "key_packages": [ - "00230f8ab300000000000000000000000000000000000000000000000000000000000000013723ca44629dc1cb1bec88577fb1b89f14cc9ed148ce6ce3433167bf1c86528b038920dc8654b7b8feded853146b4380e28cdf4803f8d4da5b9aba5bf08d5721ea03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402", - "00230f8ab300000000000000000000000000000000000000000000000000000000000000021430b34726e9deb206302fb243795df1545676e60676606f6a263ce890fd54f103b45eb1b242cb0e238d7c13fce318bebc12b1662e83c15048b06d38d8fb50a35a03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402", - "00230f8ab30000000000000000000000000000000000000000000000000000000000000003f13d9c49eb35fb98f073d70d074103424e8f2be17366f43750ed709ed5aa989802f3077e869cc5be3a3374fc7bb4b076700b2b8d973218145be36a8075dbf314db03a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a402" + "00230f8ab3000000000000000000000000000000000000000000000000000000000000000136d773a86602d4222fa947d9946b0c37f0496ee8f42c7d8b5292dab76e799e40033e39590946701bd1e5d697c3d620820479a0097a96f5d5e6cee2454ef320d73b03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000020f5fd06e63f62dc9be6459553e03ce90e8147599a12164b367200c401e9ad9e802c9952dda17cf47641239975d4aa6a69f83ae8ba0aae687a146ee0d5886c4dcdb03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000003e7e82d3461e987714d1f6ad0e79c90e89a8e5930fd5eec173b7f9c559ef256d10274c264121e801f3b609fb8d44dd19b4b63408609154c7750d4e6c536d59b4a9a03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02" ], "members": [ { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":1,\"verifying_share\":\"038920dc8654b7b8feded853146b4380e28cdf4803f8d4da5b9aba5bf08d5721ea\",\"proof_signature\":\"eebc839718bea134b55600384356b800aeec840085febac67e008ed7b4ffc65d2815e3de77f7b0cb0ceacd2b12aeba8dd3296339460273cb541dc635b46caf65\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", - "created_at": 1791465428, - "id": "fb212a4eff80ff8c139b29fba36a7c8b77113aa889de62fcc17688a54deb1081", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc\",\"share_index\":1,\"verifying_share\":\"033e39590946701bd1e5d697c3d620820479a0097a96f5d5e6cee2454ef320d73b\",\"proof_signature\":\"5cfc41e73f9500216ac5d2fb54cb55c9dd983ee1212a37b972ee195c648bcdbc4eea1712775dfeccbc907101b17e771f06ce83ede21a3e8b00a1825599564582\",\"timestamp\":1791467350,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791467349, + "id": "31a9c31b60f872e997c94fadd235a44d0204929cee95beb6204f49dbb3e0cb2a", "kind": 24242, - "pubkey": "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a", - "sig": "34def039604d77687cc497f0b92739caca023eca84b1c3f20ebe6448d5dcbae3be2273e3cf0cfaeb9accfbeccfffb8b3e0b050f90655f119559cbb7bb33c7189", + "pubkey": "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67", + "sig": "f3403ced87bc5fc55f641be1b3f4d6b5e94c57c03011b55af21803e776ee763f2d575078d40c8fc1ac46a409b06bd70c04dc6496492e9e5e988b17441a1f88d4", "tags": [ [ "g", - "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" ], [ "t", @@ -539,27 +539,27 @@ ], [ "p", - "19fefda587c2e26acfe3b3fb450219daad6ea0393d2279340622cf4e46525e14" + "178fb6dd67b2eb40c29a0ac53416c5fc9331aaaa35350ce9babe2820311efbe2" ], [ "p", - "d0a34d6afde51f2e9377db8cf7c1ede771a281942bacbcad6ef51a759cddd361" + "7e03f48a9e0591ca37ff0399df74d8a5b45764d55f0b31b33e09c84aaefaecd3" ] ] }, "events": [ { "event": { - "content": "ArtYJv2Fn2eNgzGBaeV/CNgaFT//tTyxI7LIlm8armpSf/GWuRNhRalsoLInL7b7KSmgmH9Ewgz/1xn+lvuYutGyu5OVZyYFTUZy2+7iOV6n/SZdHer9VgdMqJjOsYa1HHYXbNFF1XKNQU4fdpAZSz3AADmZiZmcqFskOsMtshXkm210JsZCdIs3ndfiPI65Se0SzRdvYr8eRV+qzQCo+YbHWXAWx6NxGi1/8H2Ap/F8sfaMyJ5V2tNRor0u2P1Q/wIN", - "created_at": 1791465429, - "id": "02d2132138013ec10afeccb57f6304bf49059f8c1b9500455229e3eb55a16074", + "content": "AvpjevDSjcR+sqvz/tli35lJcVFVGR+OAnSJZxIisLmLIrhlOP0waVOSM6ZQ9SD5lkFT8M9E3xpbOWxB5o4YeAMnYB2UE0tcr/wUX0RvrI/D8PaUkWcJVJDNYAAkqApnsUq5dVF2cHY5DJHr1JWHwAlXw9Za4DPW6r6WCUE24AoquTB3F4EyTf5miAVxbfUzAMkeajNfNQDhL0YNIOUM0/qyKJyxDy2kZh2j5q7P2juzNYOn0WfaFZI2jgZGmi7PfPvY", + "created_at": 1791467348, + "id": "1e17e0564d435e5176e3033c0cce28827640cc0f9cae14d5aab01585e56b26bc", "kind": 24242, "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", - "sig": "e7042d69baf30a491b9814e93de3b7ae378d8c4d2f13319fe1c8707b18d1553250dce5cf5c1c981c8f065559dbcd4cd83c8142c8a72ad73d850f07c74d8c3425", + "sig": "8eaa0cb9364ad57c1e91b32295f8b957ee704dff87f03f0f489febbb41fd05ffbe7bb15cb0f11542440a2632e398cc45023e0ca3bb11154cd446671a304d0846", "tags": [ [ "p", - "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" ], [ "t", @@ -567,20 +567,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" }, { "event": { - "content": "Avz184E8xzKOypiYTv3fCVFDuyfJwbje+jg12GXVzoR/dJ5Nq7vtbeVjxq3nn4W2F0Q/1CraMhK7AfgjmRkEPJNu/BSHwG3TmC59dzGXM486hQjkZC05u00PHxi+qqNPJZRlU5GhJ4kcHOl3FJe8iRJO7dN04JZql5Ie21WPKpCftfT4+U/vYF0IYXxckamnhe+RB9/spir1G2pcCsabqzBdU4JYydm5W0arEn9whkReaTE7facgJb8UtoyAv6Mjz8a/", - "created_at": 1791465430, - "id": "0f9fa941a63b2ad47b09bf715aee358b3bdf7edc579fe58e0e6d14f37a470a84", + "content": "AiFjBKtOcEQCI0H3xv4AXxfO0eZdP0PpL0hhx9hfR31+h23V0905hfnN642iQ0x6M/PXZDPtqueqsbbdYL8fpnxEYdFyod7Fq5lzLdiWbhmTD4Y4SvGBtWwA0J3XMg71SGE6OpaXNaWc39UHf0Syfo+RgoqQYJVECbpu4qu1YRKCgX4rfUPtgBGT0fecVtIT3KXR3tf6/+JMFqdTQ38jRKEW0qP/LO3A6ZhecsMqEst4ePMqKuzr4HH1Kb+XwUQsGMxc", + "created_at": 1791467349, + "id": "14be62fe84510b3bb8121428c1438ae13ed3ddc050c7a87b9e423d0d29081ecf", "kind": 24242, "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", - "sig": "6ced06286d5654a96fbfdf8fee45c78c08ee4ff6f4a9ad9def246afa98a30be0a94e0f211dfea48fdedf733911cffa429d310332fc97ffd953f6b9ed832a437d", + "sig": "dab2891deead48412b112d1c2ec52e0c947652e6043dcde1ea2a3e4eff14ccdf5d3d95d933b8a8336538375d8bc3afc6431aa3230e75b1bc6b9452375880cf5c", "tags": [ [ "p", - "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" ], [ "t", @@ -588,7 +588,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"ac7ad4973b290ee2440829576115b0eafe2a930ee4af41657adfc2f76c732c20\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"5551d4faee7e9e06126944d05bd1e4c8a1b6385962b19614aa35f3be535e72cb\",\"timestamp\":1791467350}" } ], "index": 1, @@ -596,109 +596,109 @@ { "length": 1, "nonce": "695138b4a46ab95d11e815986e2833fed7f27679478823986822ab7c495a9e14", - "payload": "AmlROLSkarldEegVmG4oM/7X8nZ5R4gjmGgiq3xJWp4UmXd/G/jm3UcQko8dzTZLyN3qQp2RLdJvtGgMHLgBzzHXgNY46zhoVvd25k5JwdVnvNabDVdewZAI5vAwQ9wUh1hW" + "payload": "AmlROLSkarldEegVmG4oM/7X8nZ5R4gjmGgiq3xJWp4U4N4ULZVQpsy5lxzbKvwzqzvnD0mndC8ur7rAUt4+Ejicp8ydDRLCZDaN13vTL1wdGv0PfkIWIK1Q7NqOga1mE6r/" }, { "length": 16, "nonce": "2cacaaf9c2617c55b497391f37f7ee8f62f271732cf83e68a4e99ac4a09969ac", - "payload": "AiysqvnCYXxVtJc5Hzf37o9i8nFzLPg+aKTpmsSgmWmsoLUB/Ye4oLsaRDAm2NcJc0E2nyD5KwAlNXFF4pes9030ggZtq3v9gZihPHIw4oJcdOEPv8BjyTiGn5HvxDbNq29v" + "payload": "AiysqvnCYXxVtJc5Hzf37o9i8nFzLPg+aKTpmsSgmWmsEw1V8NaqLiiBR+W7tnYO7hD7s48XS6e2ed64kcnu347LjJCnHaYEFDnNvwmj3UGOd1E47CkeFiXYZRdmgnYWpV4s" }, { "length": 31, "nonce": "c901644166d87da5f50f5a7aa011c023ede31bb743e6dfef44c9656c58dbe664", - "payload": "AskBZEFm2H2l9Q9aeqARwCPt4xu3Q+bf70TJZWxY2+Zk28fNM18qkBSbM7C/fMab6jL1WV1Dd1dDGcpsFMsGgu4V8mA1omHRi32I0DvyEsz5ZQ8WX9d+ARd6DQceAVaK/PEQ" + "payload": "AskBZEFm2H2l9Q9aeqARwCPt4xu3Q+bf70TJZWxY2+Zk5D9NcMFyCSvvMOKbOn123M1w1+gznK5gLYC1UOwk53NXpiFwzBzfyv/ZkewYCAL7JMhAjjTHyOCWwDjaR2I3Qv2Y" }, { "length": 32, "nonce": "017832977b614514ecedb8308146d386ced3a07d2859d9940753b591bbbd210a", - "payload": "AgF4Mpd7YUUU7O24MIFG04bO06B9KFnZlAdTtZG7vSEKDzjF1BzkHHiIZub5GYzE8RFu9z1b5Dw/ya3zmAV158/meLE3ID18TGySJpOvWpvQ0Eab6rSHVYK6m6YdGWlVFA4Y" + "payload": "AgF4Mpd7YUUU7O24MIFG04bO06B9KFnZlAdTtZG7vSEKCNPX22IL3xiqpWbMXUyGNtWDiErU6OKmaC6gaeakudxm/Bu0kjAhwXK3hBSbR7eY6X1QN81Dnt13xKyLspfuTKwi" }, { "length": 33, "nonce": "3623a8c60de9ef7de5ba0e517b662c38283614e71a72de9feab54af9b93266e5", - "payload": "AjYjqMYN6e995boOUXtmLDgoNhTnGnLen+q1Svm5MmblP4TkoALT8pJRr/HpAPGyF4CjX+ZfPCUTaRFu+JObuAvvnIoBOH4DUKbhOmQ3g/PZVSQZNGfXdFQiCv4Ail2ukJYCb74StR+eqIY2BPgZH830c3dSqC/qxjCu4hFuXb20JEE=" + "payload": "AjYjqMYN6e995boOUXtmLDgoNhTnGnLen+q1Svm5Mmbl7LTqdX9sPH3l2YE/6HJkPqucAxnJ0Wf03w6oQcgh45cwX/dkocAfNoXs4/HYmMLkv7A5/8lhdRXhisoQM9nFvPh2NoOD5e86X+GVvzXV8b9J5LNYEbNYwVX9M72z44s6ds8=" }, { "length": 64, "nonce": "aac82121ffabc5434ee427a37eb172ce4b97772a3e8d95b9414cad50611571d0", - "payload": "AqrIISH/q8VDTuQno36xcs5Ll3cqPo2VuUFMrVBhFXHQKL5nk58ruzXihgIQKArv1cpJCTJ4pZuOhVmffA9ywkIic7HF0+AFxfGEHuSvAF+4CfnoF5yySIq3p0vZckhkAh6HaoMT1giRMJ7eVibt72J+13zDgtGlb++ixyJM8g/Nxe4=" + "payload": "AqrIISH/q8VDTuQno36xcs5Ll3cqPo2VuUFMrVBhFXHQDaNY/tLU4KbH+gqCAgVGUcXrpSlVd+bCNfQmeMfE+E1vmdRGiNp6I3JEk2nhaWm4nDTHfwxioPouhREd8OzbSScWNV7BERlCWrQhWtWtefDptwxnBD2zSc4ThaUO3iLZgsE=" }, { "length": 65, "nonce": "0abae9241cbcb80f350ae383202b8c16e8428065b27d0c6e4db2b5290cb3e6b3", - "payload": "Agq66SQcvLgPNQrjgyArjBboQoBlsn0Mbk2ytSkMs+azi52hW3oyz+qYsHC8lwBa5St9/dFOQKuL0Asia6h4apUwjsJbnb2AKstV/2AwKHO4pEKt9h73fxSIL+QAgBUpE0DWYyxAW5xf2GHkGKkBAFywbDiLQI3EXZukSHdMBA6Js5O+a38mHMh1p3ntAfOQRxa4UohRJrXoiID2jlsneNfeHw==" + "payload": "Agq66SQcvLgPNQrjgyArjBboQoBlsn0Mbk2ytSkMs+azqZOgNHi9ldQyyy66B8JHvB+cQy14m5eJidPLsGtv7X5ph2v4RpEr4UmR9JnPTnlnHDpsbDFk36zE+XPhP0mKwVFAugn8VSnFRtFCdT37fNeoVTZNsEbJEDgiaN7xyLKW/MgasbTnBzj72lEunuGcUjS73yI+5tQZvyjM0q7woN4TGg==" }, { "length": 255, "nonce": "b1e50d189a764c5c74ba493fab3c745ac8ac0d340a7e6aa024bb039a77cd005a", - "payload": "ArHlDRiadkxcdLpJP6s8dFrIrA00Cn5qoCS7A5p3zQBa9unUF/p+tbByheXFm6J0DbsPcADIWuj1uNktR+T/A5ABVQ0CO1AqaY7Ok9n/lwSjcIYUsifzkIz3JF/VLIYXV4D3d2f//GuTulGaxk8p/l4yPujcwxhEgKJ8a8mS27MJZ8OCe4JuFo/+8DdIXbw+hG99/7OMUUm2AO7Kh/wzaa4zAM859QgwMcyWR12igTGPhIXwKsMMrNVRiEpQbkGPtCVslmkxG8D1RXg/a/BSjwhEv7slSHgGKi4w7TX7JRN196hG1R6ag4uKPVFZV/WUfYA+tKkqbUVczvLT9n9q/gLnMoX/zuyBrtNVdzHWIDsXNZZHbTl83fqlT3Xkd3XeHc3X23v9cza1iNCJjhnmVwhSGoAyhWNmFL7/XpDJa1spshA=" + "payload": "ArHlDRiadkxcdLpJP6s8dFrIrA00Cn5qoCS7A5p3zQBaE5A08i/wiEMP3U5hJvaBJ3+dWoFllGMppkJxUMbPDT4aZDDWATNQf9z9Ldh/M39vNm17iOfJtx8qDAodpJAJSjgqWemHHG54qRj+9/AsinhHP43Gj3zKD0IeddZRZdh4YC6qxbmO0NzZ/9ucPBhKbLlQJ1nU/KXn2OhDhFNNE0MEcu1mc1OqfAFugGVBC15a5+oMDFplvgfNGjikRwETUg77tqUH16gKrWrXYAgWvfLIQSmCZ8wD5m5Di9xpTgpIpcSG3JgWlq2e7EILgz4lAw4FAHe6KQmHfBS+vr6PYsfivyEEbSPtR15Ttoqf6tm1oZgr3RaltXtOsQj6ecdd3cV2tbqFsCZTdDV2AJJDNCba7nzYgH9XqPcoWfZCHw+ZhWA=" }, { "length": 256, "nonce": "b39a22e1885eedd78baf6e976e33bcccdcfda99b100b93cb3aa292a239e30fc3", - "payload": "ArOaIuGIXu3Xi69ul24zvMzc/ambEAuTyzqikqI54w/DIt4UqUyAABTVCsZi5TO1GtxrVaT5TD5gAr8NXlpm/xM0hUtPer7dG5v/Wx7Igzf1tqgTUMfF6PkARqiC8/gKmxlzBhOlae1iqCtwOeJPh88BTIzvLTctZq36AeFZcUrZH4QGOc/GC7SkWjScDeX7lBvtL8T636IMLozZRdXn4liJaKx2K/Bs7gEYm2lbvlq34fTskHj7JzQznmt+jfZTzK2hPZF/LKD9jovXboKBhxJUcX7uiUk7DIsiR1U9PF2JDZNPc513DkIAW7obblYHfR5HjhBmoHij+pDG4bglDJhcmaWKU+NItNUcy/kku0SbmMhe+GfyJkQJE8Pri+u+YHkkEAQo7bHvsYsUpFGFa/MpFgo68c7eesxPjxsJ9Fl/SLg=" + "payload": "ArOaIuGIXu3Xi69ul24zvMzc/ambEAuTyzqikqI54w/DI580Xptw25WweeW9ppTBmlbW6ySRcRG+ZAjD6aHQOjEOIXZJ8qWK+wwSUuty+Uuo87CleCAwQLJzr8F+wfc3hujWRwRnbcyofJZHhfdzLtWng7ZEzOVqPF47WYSqOceCkvkx5Q47NX0MY6K7CPQqAmqxQ6mmvy+IiYBDqpQvUduWY1adiXaSIE8znw2/N47R386Jy6eCRpe+I2VhE8hjBtY0hilT4yLj5E3/CInfeG9B8qgZKcl4B2YaNvlX8A2tHdJ3b5Y5TMMWREY/MjL/CDVo3uIzfiEIZcqhJPD+e2mwLed0mODzJtepEuort6JRCt+JkG7ykhTHsSy29mGMu9ybPnGlfvO5e5csQ2Gr2GMtWW9qefV+G3/iHi6LazRAQJE=" }, { "length": 257, "nonce": "b3c08b3535f61f830360708f69968daf7af5c411b778c04939a28e56fbb1f0f4", - "payload": "ArPAizU19h+DA2Bwj2mWja969cQRt3jASTmijlb7sfD0a2TnbgnBqb2itCyJyGKIvuWXS8Jf7ue3pZIxKV2YtMeZGIEVfjwPED3+mDGIozfauqCHc3uKJ/rjaCQo0K3LIZ2Bmucprpi2PaziyvM6I4oHHtTIg8c7K1sX6hhF+E9SBigmwpA1u3i4+5kusaY8ZTPwu4ybqCStOajulkld+cxM0FYNDfKbMjxdOc5HY9eV7YQ+jgb73mZzl/hzKbtmNZq4QVWl9MsTzwS7WhpyqBNN7qkMn9Is9mxZmJOk4U+OhWYsGyWXTfCDwTx0t/CLHj0VHqHCxV0OblwUTG/EjOaEODhen3ydM6QbWLRkVz9WmWFfNQcIn4hFusg0zm7RZZPoxh/Q5rdHJ/cfxU+///H8SG2VY0f7FbYkYxau0HeJGY6kimvxU4v/Nkf/c+lWos2xYidyfmBzkzb5Jt9soTy3XovJEWs2RBmX7XlWMXi9aHs7R0f29XoSM07UQuwNDQ/y" + "payload": "ArPAizU19h+DA2Bwj2mWja969cQRt3jASTmijlb7sfD0IkveV+t03wxnr2jfeAm9+had/yHmmNvrgKpUZ13Na9a5+1F20JVqiWvehv0IY10IGm8xyxI6KBVkJ80m8VG1bG0b79dSFZo8cGuxznfP4RukVe13WE2X+PHWaxEHpdYdrSjtRo1i/mm2OC0SljpAq2qzg/8umfMHK8dnnHgWjCVDVvXDIPdXlpOXVdS8FJ4sAHcHZW5J/9KDx5tc71EwM5fUb1PQPqrvcQPuX8/Xt+6Uu60eSMOHZHLw9lSW11Qrnw8cT2bomeLMLsYl0d6HBAjMH5qsQkiA/b7gBshxz3T2fBNOBnEybVSycrGXxxHdf9fLVKRTtXyTK6fSLrjWbVojLhYBCJRPux4susdABrf9rRVYNYXEz8spvlndWzQQkQaYt9mLzoY2WGnH3oWWPbXxiQ159rv6fD2UFQ4TlerKjwBVpLlmViO/tifRlFnSVKlBPcuAuR+0Uld0j/cVAEew" }, { "length": 300, "nonce": "7da2b5d0ea268ee0457993b08f40c909a8bca6dbe15601d2c7aba29fdb4a45ac", - "payload": "An2itdDqJo7gRXmTsI9AyQmovKbb4VYB0serop/bSkWspeHheDPwvCjhJ1L7RQpBCzcmyvaKQf4pCoSrszvkuEKkFe2XcHSj0+wdPlUAPv8rVa2GqORcsZFkvOImjbnvzVHBvKy3mBJ+6EBhtdaHtjPUfpI3FdhQVv0uFYE6+LzmRbLE90rv50IUgXucnLoW84wCzILIYsRSxkaq7B9YS8p//bTqSregFZXl7WI4RcD4+lgaQCK1jA/RYo2eAfE0duaK43UtI5cqp5T6Rr2hxA/PhGqD1kBqAUVOQqd+qvJJ8o3KF85suQnA9KD4dXsFxmM2J3wA0PUWlPD20ALmdCfPy4gTT/ox4oAfcXv2EmXL7wZOe1Uoun9Tb3Mk+WLjn+sCTq3yqgK2rxhAFAe9M96DwPzIOWN7Aqw+3TfILqphi4BB7R/6hje7RkRddPO+h0aqTI1nuWA0TvaNJe9b6OXT/7A2BPh44eFSfcnixtJNTGiApb6qqy+69jus903Yexwu" + "payload": "An2itdDqJo7gRXmTsI9AyQmovKbb4VYB0serop/bSkWsyZhbkBqpDclkzEButiRYxvbCf9mwxteDRsjO5TLYkP+mMXI6+tYcZBjWmkYwDgvebSUisouPeeUduEkLAh1mm2B+okdNg8PoGLoz7Fo+lVJm7DTaSxcipUDPq6KO5spBcvCdPnEUNqa2L1fpGEpiFPNJGCbXalSnhXsfF5siLJg7grMLthWCXQFNe1rbM+hAgjy1vfX87d+gedCem0cxZ0Lkq0P5nJNC7abluCd1aLlumqob+lVMRdzvVhL9B9jInyU1r3szo1i4vzC8FAeFMmxxLSDgAcB8NUIG0m7ixR+vluwt3+YWt49Mw2Rr8brrKqg39f7DtRzVz8d7Sf3RJ7cg5HdKei+nrm2XIXISfLKAXb+D3FG6YsCSdDEI+c4JUCb08lEULdoBzpZsoL/lkArHb7CgIhVSn6+WeIWwxLHuBat7Po5q+ubmBVHEOcLB+RCKkWg76KpymjwuNyIL9oyP" }, { "length": 1000, "nonce": "8c11c3f49eabda816523f24b6e9fef700a4ab0bc3fcbcec3905cf485134cd6ab", - "payload": "AowRw/Seq9qBZSPyS26f73AKSrC8P8vOw5Bc9IUTTNardwjcaXNpOBF/vSYYvyQHX78A8PoySP5jyyqe0GQdw6MsZKZVsN7oYOoRgXAIWCBnLSWv2w4S0OYTFqequzKxm2B5XujA00sHmfqtl3ih3G58BjIcKbsNiVPBoF2PYetLXS1nkeVU/mueYerJOUuxC1h/4IzSryqPy7BQzTLekAy8A/RSbQOH9HKC9EXIC6DVs5IYt1nNs30LrTXzqMEZ9ur9y/UwxAnFfZZfaOs/UVwSNAz1gpIEj9R5gR2AL6ut4LjTlI1SbfIlTpF52Bhaa9AaXqEbyecrern5HdYpk523v2GYZFtkv1baYAqCEJr5GgQV9gNeZ9vhlDT9QUOR63T0IpLpu+r0jxZtwWgl8K/9XRrvAKDZW1MLEuWPyQQfc8Cv4ZOwtI8BW2ZGLbyIoDKXaN/uKkZX6XLRdafUSxRUkPWyekgFqf/VdK27y5ivIw82mBWaN5N6iCR1/vY7JXVZc8VjlnNcKI/DKGQZNCqrrYoI6ThJX/g7ur+cRrBweR3xna4k2YtkUUpITSGhguSVhTJB3Njx4QKozSu8KT/89JINTB9+Ac7vGPNbOVb3JV4/W73/XfQTdD97V9sSW8NGj/a0h7rkEzx4XLH7axh38MP5foC++zOAQ1QoBoNOhpv3DnwmOiShLc7l+6d4Yn4iO01mMdJi2D0NNrlpMAJCfV0VC+nukRv92+PaIUBcbxBrJxwmjKXmBt5xJWtJ99143yMkPf1TmgFVNqmr8PhycMuUVBwNWUZMiJp0pdu2JgEDJvUBrGBE+3Rr38GlR3iv+rscEy6sgcpbiYLZUw0bhFW3Ryb+kuueG83Xec83rqjYyUYcpXYrJdYEMdcNMh0CYNVocVOasKHbmEP4/WsY15bc8rsUxEgEjTb8DXk3TrgfXB5OrB90YUJuzVh5qYJxlJsVp6XvJK1ebGcAgFdQAij3HljRkuLiJ1YA5w8rmWQqTQY8jtHy+4d3uCl+8sv0FmJeI8LiCL5nM5A9DNE3CrFTEUif/+jB9fAzTwQNu1m+0fxzlBeYAg88VR8IDLvmrMbFtDP8pCZhftebvi82oerqVIj9CR0aNrM8aDIKpegSt2EiIs0wRoP74rxqGP8EWDVa/KRb65YlKpFVxatun2RTxrOCKJMgYqQ/7hrAhytMQYc5EHrCV32iEVZMmAvUs9PgjHA5QXcA2TFDWLYMEVvC/tCrecO3mbRQCOPQd+dOq8XPHopBLAEdtOhvD7UcBwpdMsQbGwG3H40DD6QI4hwkextJG5do/k5p49xxs0ZwK6HDEL7d5cmD12P6DGdqsyDaYUOu72z9HiZEaJ5clZL9uYGUIwjkhcpuc5ByN8BcW7aUgHlYZpPLsZVIs+xKp0wsMiByoB/9yeJ5LGfyOq/n1zSciMzQKsAdYMAKBAI=" + "payload": "AowRw/Seq9qBZSPyS26f73AKSrC8P8vOw5Bc9IUTTNarzRLyXI0Z/t0L1eYzmjbCLtZJX4H56PkxcZ4RZs8hlt94DdfMIkq8xfAHnVvYFtDCkLFYbIqwujVXjfPHIVGhjY0Cpl0TydhL8kBNKg/CbmhbupyOB4K+9SWMnGPTHLnhDp1HYYwTXDPF991kS0B6dGPkxZHRa+hNmKla8uVhbm3KTjGNDx/AVx+S9en4d+683mVEsFhWlk7jNLi6Jlp4PS6XbAmCLFrfaw+sEyrLrlxzGPxLr8FRl6Nspfz/m7kJObjof39w7p+qhf4hezWUrsFjUVMHmnT71B6sUlkvKkripjzugD/fkUA6RdplhwGOhaAtfDdsj4tddeT+oaHmtfCc7ToS9ePz9qIBFJe5N1ixe1Q9aGHcXtK6j0aqks5nqBp1AlcHwYr8ofW1LwT5sEK29NMYnw8sVMlzBJBxS1R1EqaX1DvvsOti/oOyJtT7adYkVpxccy7IZvfMmLfbM3V896KANVq5Zdx4/bkg5Gxe9YEm1rYZfwfiBAZgo5pto4Crn6R4YmkykQyI8pTKG3/LFRb5Etv+GBA9YWbrjso8weXkKnabEbhO73eXwyd2IswQy9jGUvNnta5VR6RQkFb2Fmk7jC1PbW2/EzhiibtNb/Obym0MjLdNThBUSOkCBlx1nUP31wcmFLcgI9nc3Lz4RWKCgFORrPZ0g/5rClHmAxbksqxnKwXyiuX7wqWEtC7HwwO586no8tJ31MouVRIJ5B+c3Cg7UHRWnQiiP1IbYwQaglDtyHvUJSj5VfE9gQEWRUg/ecucJztHB1MdO47h4NL84TmWq6rPHkOh2d9DqiWbR9ASIqAZuGU87H3POY49hR4ew6/arlcdIdbJmTBEdUawZzMoH6yrzTGy7yJW8N0lCSeYnDqyeDxgq0wXbydvR6Dh2Vzh2OxFCJRHN89t1EJ3KTSdRoo9fwkA1NqkpIz4lEN4+cdQA3C2fZ+oEa02qKqw6iHFYurw0cc68+V5E0PsuuMCmjrw+FIArGhs7Q3MxriVFCjaMHkGnsnUWiTIZ/VtHzxGAmcTV54rtWTItKhjZeBUYNb6MSZ2l4sQddkeSKKwozg6MW0e3zIClTAiPA10gezgP/rpri64pTzN/S34n78TOqYa3Wad/DgzoHnckcGeDhrgZQ1hsG3z2tlfaQlsh+P96T3JLuVM3+/nPp2bXvdAw0J18CIQ9twLsP0TqMhfzqw1h28awNzK1R/LnLOe2QEnnCc3SLxMWzyWSSP26lWzazKGZFqdAPFvFccJzntPSrsO4RA3FciH6/Ct7tWavFbSMpUI/YBy1gCyvNMkCqIPtQ2lEtkiI33plzIYpPqsIACFgmozgJQyG8XqJbxHZOh0qQhimODrColGs2nOqAVZRemRW+nIgtE1mbp748t2gvytj7QcmVISbJc=" }, { "length": 4096, "nonce": "e78e69c1782b1e9dcf758064e2376ea2f73f8327eed943c4a0696903bc33dfff", - "payload_sha256": "bb234845e942e8394dcf29ab790d33cdd88d484daa230972144d37fabc672480" + "payload_sha256": "fe9ef9a0551c7d52e403004f20011b78c0c7349e21d57c9cc4e7bc9afbb881e6" }, { "length": 16385, "nonce": "a0643ce5ded80d33414e78a3aae6e3d48685841af294fb8a8bf2f69fe23e2156", - "payload_sha256": "6299bf335b9505c8cc0d137eedc92fd5fee4c1b4258feb25df032d5fd9159e1e" + "payload_sha256": "e31bfff1381add7ad7abe54116f9d5ed495af617ae075f7e91b4995b283c5367" }, { "length": 65408, "nonce": "4bd481c509b7cb6dca03927ad5937f890dea5d0be4fff0db37617e9801ee58bc", - "payload_sha256": "3efe5f6095014b3469c264998eb8daffad7e35542d671c5b8fa74ac352269bc6" + "payload_sha256": "19c4097c0ecd4e8ae9dc4f22c0c687bdc4e76a7f5bf3e02eab5369820355728f" } ], "peer_pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", "peer_secret": "ca569568f08eb04e77a3977e2383669b0d256fa180647f42b0cf94478678df77", "proofs": [ { - "proof": "67f487862c35499b4e1c75671f1e05a578d75d520a46a06e761a44091076078bc9304e4c4191762cf770cb0dfa4a755714fc5180b9309a4b4b1b0d0b39da0bed", + "proof": "c6da212dba4edb75d288d5983290b74e3e909ee514afeb63bf66e467ba060bdf95d032d6c5605ffa34f184683c4a8519a4bc770d75b5b6937ff1eaf372dff471", "timestamp": 0 }, { - "proof": "81ea3b53366c57c2ef5f21356169472a61be81d694f8b9c3e75d61cf7c916116320e93a5b4f4385f94c778ed108fddccbbd37743f609b464e0a05251d47eaa1a", + "proof": "4c78de347c8d39c3675f461dbeb95459bf3bedcde79e3026c711879239c9d369c21dd36e99686d9e87888fef64aa3b46bd9f9b93cb9dc3f3ec93c43856b7219a", "timestamp": 1700000000 }, { - "proof": "e8867104aa0724031cb6c2f5167131bf40fdf594aedace2ef9697db1fc4627618ad9340bc391328324c44773c1dba0294d4481262c1e833ca279d15cb8573830", + "proof": "23cc66037c5233f109ba6f9ef711961b16d896fe01c143c587cb65a490e5227d6eba89b2d6d5e2db82a9e6edbfa97e7804912d69d1699553ac1714a860156450", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "dc1a81e527f7b0ea474bee728bd25476464d47061e78a0e7aa0be3927adc867a" + "transport_pubkey": "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":2,\"verifying_share\":\"03b45eb1b242cb0e238d7c13fce318bebc12b1662e83c15048b06d38d8fb50a35a\",\"proof_signature\":\"f8bb71abac1862e8823c450bc72e75e62865f9f4ffdc75cb585b1f4a48b21123f5d6ac00111859e7e78e3e325798360d956476f460459891a7518b0617389f64\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", - "created_at": 1791465432, - "id": "42f3bfa7d1393f293619d65b5e0d003267254e5886f0782b0d5ad8d058ce55d6", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc\",\"share_index\":2,\"verifying_share\":\"02c9952dda17cf47641239975d4aa6a69f83ae8ba0aae687a146ee0d5886c4dcdb\",\"proof_signature\":\"9b23771676f095f60d683bb15a42e9e601aa2925ec7dd5d44267997164eb98256ee794641b207d0a377e9576e6c6fdd1bdca2b71392f91635b85d0a0661240f9\",\"timestamp\":1791467350,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791467348, + "id": "118513fde093594c57fd67ce3a46e448755a6375630f6fde47f6c3a29f944e88", "kind": 24242, - "pubkey": "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d", - "sig": "29b56b944ab0741e05caef13131a3b0803d88735982665376b3be9f49fb0840cc76c8e23cb52f8e2762b29d50a07502540e4070f6291cb09d3256b7417e3053e", + "pubkey": "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f", + "sig": "86873441708f63e4828482384a44b77fcb493c0242e02b1abc2dca9565bab6de62b194e715fd1d3f4f5d153bff25227d980d0be31826da5ef25ea438510f2ea7", "tags": [ [ "g", - "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" ], [ "t", @@ -706,27 +706,27 @@ ], [ "p", - "e76c7a6faa1386b239979bb5f61355ad5339b782170a5bd296284809eed623b0" + "0227fe07fce0572e529e753cf4e0eda5b56ee794919639b42b2e42d68e064626" ], [ "p", - "d0a34d6afde51f2e9377db8cf7c1ede771a281942bacbcad6ef51a759cddd361" + "7e03f48a9e0591ca37ff0399df74d8a5b45764d55f0b31b33e09c84aaefaecd3" ] ] }, "events": [ { "event": { - "content": "Ai/lO21sUhh1E6fh+kYN5Fw+nEgx1JqX/c4KSL3BjJRVfS8qnfNVJM0fdEW1IeyevKoU2/GPmPQwvTfbqquwU3yiSYGGUUfISR93CkQs6iBmbK8W1R9Y89r9pxAek7TB102/NOLWD7v9cHTYRVMkLNZb443gmR4sObmVOFoRV4VPNKZ4wja5gyNjysdasYxLlV9QsU47kLnxJqWOXxAIoBAY6cRFzRqtSRBAnReWb/Lz9bJhO1f6Ttlrbjbsw1lc7WZ/", - "created_at": 1791465428, - "id": "5981a946a935348bc039c125f3923d4178b6c713844743d683c85f0db278ceb6", + "content": "AsSFE6h9XNn6v8Ymi5dCpgPexhtIYJaDGIlM6+6aTieOY+HtGe1HnsmEvADr2blWJbs1gX9IjBCXsvwPwpBWpxn/w1uFY1HE6NNdV/SNrZfqC8kIYl11MZqllLrFqsoh8RZRS0YiJrecT4OPxspmo258u5gGXCnIHXIHCC5ZIkhSSZP7IqcG3Kr7cD0G0ILqGcY6mK0mpszvZqIRuJYOQvNW8fG87zDZTdlzRTBmq8trOGrt60ZeBUnyIodNrDHoUM0T", + "created_at": 1791467346, + "id": "5cc3e1920c54884b8c2eb2c1aad1354056799e76ffa15a9afb00ce24086a4606", "kind": 24242, "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", - "sig": "aea01bc5327fb1a71b4e82e9d70126c06931025c1780a9fc22e9aa31fc825617df04d15e83a6fdc6625f43b62a2e1802d32e06e29c9b85f8130785d778d1b7dd", + "sig": "6049262e030fe25bcd50d0c6f14e229de7beb4380c75a4c8d591f745091af4854fd6725e7518ff82138154279f4aeeb99704d8d235a47221697432c2138aa58b", "tags": [ [ "p", - "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" ], [ "t", @@ -734,20 +734,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" }, { "event": { - "content": "AmT9f0WKxljGZObvlvvprNniBwUhNBGz0ltxXR11E9SGq8sfSwRzmziBgKPJfrnYY2Nsymg9JkPi2vpsSFEEJVxZXJb3rNSIusN7/xGTxeuM1wyrVktBeQRi38pJh2rCjpZE4Et/0iZVrr5zAcWsbeqiz8FoDbpOgAZh9mJFrvE93iBSm9v0pIhYRHnADE0x0NmP4dqXPmIaGgj1UqWG+vKPnfsONHxNliUHQqUYs0uW1xp7lxqMpITrHBva9czALthd", - "created_at": 1791465428, - "id": "6868e6a98d9c8fc7e03cda50b7440adab35d691baf92084fd09e6aba493e7bf5", + "content": "Ar6oY1Eoybm6Cj6jGlbOkPA+AMT4LZynKjduny320rbFhKt2CZSIGOrn3S07u8LQ35jgjeHyidS2DQJN2o4d08V7iL1vfEdptJkBiVWchgUCh7QJPBKUjB2qzFpdTFo1VVsRamZFfsifx7ag9dMJLLWa8zEIwL1v3y8MgZQfoe7w6Y8233/EQobLWsYyL5G9o7JTqhQVyMXJtduU7XRyszR3LrL5905+wYB2JlU8viXktwQqh94mLUGzxmMZBD7PkDpp", + "created_at": 1791467347, + "id": "90b28aaa34031beed4a71d299b93f0662249b08b73948db58647070cf3030be6", "kind": 24242, "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", - "sig": "a202106842d2d4707cb0a7dcecc555a01f92f001599ba59d36dd9c121109452fbc73393fbdf0b8a4ac6829eae4007ff6a617cbec8add6627e4cc54de87be9dac", + "sig": "84cbee28339ec5a43f97fce91278cc5861afd6dac0188e89785bdae365cdff4f7297cb92ef71d1490bf4cac224f59818ca84c433844272940e1992b5901b45fa", "tags": [ [ "p", - "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" ], [ "t", @@ -755,7 +755,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"14f5b9f3811d3a7b58b5da9c704c23c12dd81e1aafcc34fc9c2a757961a6973a\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"213f211c85381ec156c1c2b6d4bcec46d311bdadeac36adedd95b023ec91951e\",\"timestamp\":1791467350}" } ], "index": 2, @@ -763,109 +763,109 @@ { "length": 1, "nonce": "023adec4b3185e853d29bd6d700791a32ffe1e34586a96e5c7b6552e9e2f507f", - "payload": "AgI63sSzGF6FPSm9bXAHkaMv/h40WGqW5ce2VS6eL1B/9Ax8xap11Qg72GABgG4C8K0upKj3u6DPKOC0Gmt5R9zVYeRMXo/h/wdIhu3ip2tXCWNCgX8Fyq2ERDuycHDydy6u" + "payload": "AgI63sSzGF6FPSm9bXAHkaMv/h40WGqW5ce2VS6eL1B/b20HODjLmlEnhdB1wtubceKRLunXgwQ5onP0WNLGJA/uGjMLEA83vHgOKqFI/xY1w72rbOyOohnz0w2vd05R0WuP" }, { "length": 16, "nonce": "d923bc84a276b3952a585baa2bf3cbc3a6ac5064b05a3f3b7f54ec7b89a6f2a8", - "payload": "AtkjvISidrOVKlhbqivzy8OmrFBksFo/O39U7HuJpvKo8ZBSGpJl+K1KZpPpYCAHMV0lGBjV7JL5lMjqtfQfR2tqGMjWB1Ki5N2jgOUaiqrkThcJHA+KH0jiHo2MhL8v4FX2" + "payload": "AtkjvISidrOVKlhbqivzy8OmrFBksFo/O39U7HuJpvKoi5t3NcJotCZkiZqsv3E+vIY0+pUWEsxxYsde2uKLL7tiU+Hm8XlNESNnOm7fHqC01v6e64h8ER3P4KX+7aBa3Wrs" }, { "length": 31, "nonce": "456922bf1d29520ba0b9763da22be2e4af1c95d0f77c6589eb1ecbc61ce06392", - "payload": "AkVpIr8dKVILoLl2PaIr4uSvHJXQ93xliesey8Yc4GOS4SQiTc3IIuCiesuk3txhN/Z0N2q0vnx/Bti1W9t2X28lyGNGiSw2a3cU1HJxXwyom3jfw7AlIs0WImPIHlMBu3iE" + "payload": "AkVpIr8dKVILoLl2PaIr4uSvHJXQ93xliesey8Yc4GOSLaifWjadlUmzRPFVEtrNdmex6jfQYoY68XhbM50lHwR8hSHA+UFDB4F6CdSA8cofsIu7B/hYkFDhREfljTqEXM34" }, { "length": 32, "nonce": "a4646a505abb3f5b267decd7e8d18a7dbf05bbd06f9a02c5b43d65a53cb63fd7", - "payload": "AqRkalBauz9bJn3s1+jRin2/BbvQb5oCxbQ9ZaU8tj/Xbx8VZyO3ZIIQA+TKq6B/H/6dlSP2SgBTpL1hjuYA+C2LhEXNEwoh8B6APkgyEjUq8EaK9fsblg+ufFkSg6+mhEpV" + "payload": "AqRkalBauz9bJn3s1+jRin2/BbvQb5oCxbQ9ZaU8tj/XvOSfkVVoyql9mT9eB+n9J8gZOn2VwgtzyVRk74ikUeMkWoC8uup7t7wrZJrlJbwOLNuzsHpF9rWPgE29kQxQjiHx" }, { "length": 33, "nonce": "4d975bf472a17c4b1e1598e0ff76d76f54f2a7ee8a4b3063c856f42a4326a1a7", - "payload": "Ak2XW/RyoXxLHhWY4P92129U8qfuikswY8hW9CpDJqGnkKUPyqplqTeq8zc+BF7k1HsL/M9q42405DpBdLtt4EM1W30/FRFKeK2GRsKAOirZm0i4AgojeUbgOTU/It0QFQ9dXzDvItaq0uN3CzQEtP4drrCl7+C0xJ1deuqpnseI4kY=" + "payload": "Ak2XW/RyoXxLHhWY4P92129U8qfuikswY8hW9CpDJqGneYV27emOTk6IdHGwi7hnzBb5OyshPCHd9N2WHUEsdP5LXG1FiXw4UTypyWgIpHnW+ue5XQq2HlCQ5tzr4jButRfi2aRNgsSIB0K2gAsnZ5dY269ZlzCyFA4+ScjDz3Z7248=" }, { "length": 64, "nonce": "1a0971dfcfec48a57b06b2326af0dad4d6f035cdaed762d83a8532fa70ba33e8", - "payload": "AhoJcd/P7EilewayMmrw2tTW8DXNrtdi2DqFMvpwujPoOHZeFdG1ZEcQala9iF9T2T6WN2eNjGl/88d64XlFcFUNiMmMM9pUD9bbW5HtrA+5oknqocbPBer1iTHkan8n3+jvrdgjQPEQnjLR56RcdQFXTZ3AVxaiwp8aWsjc60yvwSA=" + "payload": "AhoJcd/P7EilewayMmrw2tTW8DXNrtdi2DqFMvpwujPoSyfzC/T9WHRM+ToBilg03PBv5+EDeH2dQzmGWOWD5HecF+vATRobLMdkKBsT+wCFGQeVYObeHgUyAilXqgozUbT6OE2gFcXUFwF9HuXwAAUyYL7+CxmlGZzkpAInJZ+lNtw=" }, { "length": 65, "nonce": "bbefce463d9280e0ce16b3521d4619103483f632798f41fd16ae0fcc3d218752", - "payload": "ArvvzkY9koDgzhazUh1GGRA0g/YyeY9B/RauD8w9IYdSTqGtBY/jGsHhTLKcvccm+3nTyNGshGUqqq+PtYJc/IKKT+91RiXNfOgJUCaIjlmChdyJdMAFuYFi0RIc0lkejV65orWtaBs6OSc/S7wdSX3Ib+H+0zjvO8YD+E1FyOt+jXuG8c3t5wFHBZr8QfAsDWZJS26NSNhkXmzY9datbzb0rg==" + "payload": "ArvvzkY9koDgzhazUh1GGRA0g/YyeY9B/RauD8w9IYdS8xiSP1ntrL+cxJCxGn9/GLX5KUAAVC+Lyumbw5LTVIYl+K91Tx1CfS6cYxEsmzhe+pQg9+zQ6wsvxXpf5x2fSv9owgz5zItPZ8tfChRWFV07AiAIGrZsTKScQ7HcIyIB1CcsKyT2yfnKLdffHKe68bRQ9RgHj8ex+U4y6gWKitzSjw==" }, { "length": 255, "nonce": "1097689c08b5fb673c55277aa3e9cfe47106eaf9b20e42d0ed28814a4b69952f", - "payload": "AhCXaJwItftnPFUneqPpz+RxBur5sg5C0O0ogUpLaZUv5yc1mDq9KkKSKxXsLPrl6CF/3YqtrGngjfSTIn79mRcx+vFEpM4B4DoYmpAVVLB+y18zSRkxjWc7hYDjklSJIw+D/8sc0Aa9WYwmnMZQJi3FsP1ZB5sC3HZetFTUn9pasvKDtqYWEGrsWwjVdONj1uqzBFD9HofulwTVfERoPvPn/hnh7GS8x/7FS+DaiUeh6Q1VEjArdneR5zp371KDQEe+faNIx0YoXhaM5S83yW+Fig+Nix+cnGEcnAep7eeUQeeRp19+7BQNpAB2PMbuJ2mdMUMMnqJkepuv/iydh4M+Ko1t3UOzPDddAMhuSxhIvbAGc04ENEEfuXmWwFsoisKRd7STIkhsEMuLHaVxmBHlwOCghCaMDpVtoel91Bb0XOg=" + "payload": "AhCXaJwItftnPFUneqPpz+RxBur5sg5C0O0ogUpLaZUveuDpfocCYxJu2e2Y8KjgO7W1r5bOvzJk4GpDtU9idnawP3AAZqo8YLm2jMjLxQx8fbFTlyJKznKsFRkQRH1WVGPglJDnUaroxs/TTnH4DRidQZEVOGLJ6xuTcd2mHETAtBEvZdhwbcuCjYVnqFqpg7QX7LpVdS95HUy7Dh+RTOk2IuGC4tfSfGOi18W/AIe6v/DyQpp2yNKwtcoCmzKaZXZzYTgGgNdc0Itxw4ARcvVpXJx5twrKh+6Z58y5oslpLbo088GUW8uYlP+twoG3HHWF5I6ftq4FIe22oVRVhlYtWDmqZPcEEv1hh8MNYdxNHby7xulYd3L26+hlV8vmKYVwV4tP2rJ2Z9haitECBLIQkv8n45j39D4heGpOrktwqlw=" }, { "length": 256, "nonce": "e155e03bc1ee3afd0b4979a151da38090e78c3d68b318f67d617a8032f454ec9", - "payload": "AuFV4DvB7jr9C0l5oVHaOAkOeMPWizGPZ9YXqAMvRU7Jo7WPj6Atb7ZTZCpdCi/bybbyYKAUdHSYzQeKJ7Jbcfmr6vJ26qpG1UE2hzWHT0T2dkMWCpkkfe8pMd7oXHnVF+vbhdctqSzz+tYDP5I1ObQDeRZM4SxU58wTYiGQoppvbUK8n3klKeYBLqlMroN84ZV8EQK23Bp/uGQH4Tnu4PWWsgkTYGXmY6v28Uiz3Y1VChlWVqmHJVMpu5opVhVxHuMULlqQd/MIAvLpJRAWqRa20blymLTI8OYMbJHxRONl3gHNm6tsoMUFXlQFpuGLCkVbA+Bb45FEqd46uStZUUp+3ykBYIAiMMPHauO1hGD9KklZy3nzgdFgA/YKeOvcnCaoQFD9uAo5TK79wXz7f0z9WyvwKe87lpMyXzpJ8IQJPes=" + "payload": "AuFV4DvB7jr9C0l5oVHaOAkOeMPWizGPZ9YXqAMvRU7J5bksUjC2XxTri1mu3L2pVRCaSbW2vmpp9NqH2YXfCj/xVJUYIAaAenfwr5ZNPdGVaapajEKGKdje5dBeH5R3LUgqQsqGNxWkEi9Bo3ZSY0pvli7yE44Fe33jOXgGATjqxFGsO/B8+0KH1GISA9NX2Q2RNMr7KrMHoE8jQ+BJNLrhaKlkxP475yfzpWex/V3XIJhhhRuYpz1a8N/utmeupCFxqWExkGWJQ48KAwcXRfR9fxVBCxGwOSdT7FJr3h899alh/NvWCHuwB2OlWvonwXo5E9QrPwli50HcvYRUPXniZXSlS3iEpzBGepeLf9b4ztDuSgGrwHWtaikGsB5j6RKZHXjgCmJGlpALRZF+Zsekb1CRmclj0/PSR6bcSfRl0BU=" }, { "length": 257, "nonce": "65e20c2b49f2b48815343735e35bf7c802b98bce8469cdc1f962ad3494a62dfa", - "payload": "AmXiDCtJ8rSIFTQ3NeNb98gCuYvOhGnNwflirTSUpi36T28XXS52Z3t0jpVrOqUyTRrBPwExYVr4qyXh5Em6kzGbBA8S8MZ0z937Ob+c1pmX6kKnkKKd22bFlFNwpe4FXrRKSlQ6Fg/0NBoqNZRIdVGeGKPLtPT5eA0ncsdWnDKlnq9VL++aKAolNix5hB6vpbELB/4ml0l7FDXRClouulgmcLQgya6hbi6SaEkBwW/ddTGwz8zlZx6RB3wOpxnJyJP8qO8QtThmQMfgCuBiCKsxGVoLnaSN/tUuFlhH0XEubeZdi8CPn/L5uHxlwfrXiOIPgDXIoQKlfgSQGg93MDvn9X769q+RP4VmtLQuLVSJPlpOM+1MjEU6lqBzk/uLPQ6igT7gKElCgmZY60LwM9fHA5DFOL8jbHSxvJ/eKEiwr0Dgd9AL+G7iwu7vrc1l+is8Zlp9+8LmhtzO4ovf4A+V2c3LAG9XzVj0rlR4FxOHCfI7XcCTOA7Eg9fskgVArn5k" + "payload": "AmXiDCtJ8rSIFTQ3NeNb98gCuYvOhGnNwflirTSUpi36O67z536FW4nL3IK6XK+csZIXDi+NZC1QevmLGLj9eH+3KLUIZUrDVbKCTIu8eksTKCuaMkUNyYROyKIif0k4jCYjy+QfTD8kdp9BmItI4cbY6MTQbIFxdVQoWIu8aFvuVqnJP7XLbwtL1pm1d2RSe1w4C+wa3r8dZkHPmXrt/myHrC2mJI/vQoUxWj3CeY2W92i5VcO0K06Z/uvl5sZYBalFJiwaTkdn3tShAw11tfUdlhTLlsfrNg1eFGaA158h7PAxqdZ8l3sfBU8Kezfjx3IWcfYCeFBUQeexDLrm3OT+x6BZBxltZITBdazU4G9mo/ZVFLOxUW5lhIVuAt4zj9xIt4/oq7NWMTQtoDcud2lmdOeU/rLBsB/wYGN9HFnNC2RM/uLjZIxtdzOtIwZOOdFOb3WlvGsUE3Kph5/ur/dY4NSRCRxqXVHaF/TeVmGlbf+Y3HIPTlIBfOVDt2sdvcsF" }, { "length": 300, "nonce": "50606a1aa738b6e15b93e2e97d55165471996867bb523ed4161e91f8e9a28594", - "payload": "AlBgahqnOLbhW5Pi6X1VFlRxmWhnu1I+1BYekfjpooWUoitTF+Hs9ygUFAvK582k16OD4lxnc4IFtmIBLhN9cqjKtK+hgA/rnYqPiD0thXghD8tXjozmxnvYIcSFbLJjVvKAN2KOAb7+i+QjI6AZJy9Q2ifFuv0XopknRYBJT2UHATaaylvdnoqCMcf7pJFMUTuzlJlfzXp+CSqgaVtqDk8IZte/8z3HF+fpiljQDFELUmS3kWbGFObsZ1DueTDTHqep+6OCwk7X36xQGY5nU892AojBtZGxl6TAC4jo1dFGk6SwXfkMc3U+3WpvKZooYEgNG00lKfA9ZztBM5daXjlXntgAZZz8p5ZLLjlmxECBsFQLQhju0+41yJ7UjndRQ71DRGSgzO+fGcVpJyJeL8YWGsSrMjfPWbQai0Od+r/Qdyr/eNYYDqdnKpArzfH4CNAlfV2uWDXO3IicQViRu3+h9/TF85zTOXqrKrOLayGLOjrIAEq12ivvRJCoFbk2FCWt" + "payload": "AlBgahqnOLbhW5Pi6X1VFlRxmWhnu1I+1BYekfjpooWUTb+Jl8UH1+qrvaeasa4OnX9TCpOsQ5HkkmDeDqGdCYcEHziI+JOqHLeHj/Kq84+ZA6DzReT1LMyt1Q5tJsfYtuOIUOsayCHgfL/ZscaUH+VZzlKq3UXPb9vmgK5B1iBaTUd9JevUxGIXKgNo4xHaDMI/fzoZ0ahxpktMKvPFy640arHlKCQ/0JCjQaYxDPLJTidZ6LxwaeCxOhxnhRR5xbiKrTZ5UyMgRXKQeDPg2g8zDE7bfGDrtihvt6cAfG9cEZEUQiWWwBFeaa2eKwWNkc3NFFFjipHawjXoTFh3wykJA2duWPpHp9D+ztwl8OISutyahFPdKmlrL2tWJ6MKhq0YCLkqB3IO35n8i51tZ+pN3LhtqVSW/bRJQJTI8mijldSYIZxdHJOhJ3pvEcWGDuhLTaxtdB7TG1JCnB4LsqfozAMWOfCLpYItbNx7vmXi7mHpWHZ6+qXc8Zqy2H9Wst16" }, { "length": 1000, "nonce": "aeed88df44b7d7a6bb8f6ceb7265e04a9b8f82c5fa524e5ec2c293a515e66126", - "payload": "Aq7tiN9Et9emu49s63Jl4Eqbj4LF+lJOXsLCk6UV5mEmrgBbBcbs2SJPArqgLKiY16E7bf7ygwporRDT/084xFCfA2l4LffOxD6JKn1gdtKIA3XzAja0P8H4FH36sgG8NJEUsOVXw6hM8GZ1ZWhrHJrl7UTu5fUPuglqGYyTSVHhKwtfQ7h+oxwCOmhBciWMKi1A9bZ21yjIcxsYNsuFnjw+mzBSJecxHjsv7IhRaLZOzo+9A6zNmqJuYftn6rDlSsavLWl+gOsAHTtWRj6YkOZErW21llzsbDS18DGon8leXisZqCtYXbOhHxipxLuB45ErP+OjXdmfZIEaIUQgOeXJesM7j5tEFeTOM3AT7+IIMExUprbc5rHeIWcC7CFy+tYsot1M07Ey8Q1zgDO5e6oyMNyPLJwagMc7TAc04qsCftL9cbzpUNNjdLMwZvW7DI/LoGIjHg+3HSRMDyezIS/3tnQ7hJjwhYi4N7h0+yYasvkJgpY8RpCyEd2kQOPFAE8CeyfcdglK8a/A8eQcWec2kvX7oxmF0v8DLw6/3tP7suzmb37HCCceytmeHphOIM7oS917+xZWNVo5eL/oRj02wtsLiin6BZzAY13U+v6dnFqFSOvNF3zakex3nExTxZgoO4UCzMOnY/rnybhBQ4i13fXcTO6aQTNf1RdDvk9ENF5ZieLnrE0el2w9F7KFRWQFAyFFoi1waQ5KX/Je1Ul1Woa+mJDp6OsNFmwOZDAK7TWPfSd0bXXTtw2eGtUhcEKSu17jmWF+y4VjU/TJOlzjzDKHWUmBw8CwAZU4FItNlyyYe4Dx2g3a8SAVN5guhg4U+/fH7rY9o8CO9ZRmM3cZE85dXVhoulSyxV3WEIXbPPCnj9Jxd4tYsYAVEWDJtClmOsyE1wO6S8N0p8hM8xul5g+ZQvxnFau1OrLp4akq/cJMEvAhXFFoJTnC1wAezU+jD3/9LcfeqNgT4jc7tZ1h9wm1piH3blGth24933ZYd/Avexc9Z1vg2t1vT2C+xb00sQAxNrZHBG8a/JoCWb8Q86240FkJ3cODjh+x0OxxxngDJdVe6+QXIARbYypl8xSO5uY0OH35SHWMc/wX0b1p5ujeK1Dknp2gJYGOlxUWQiMEbRokRQdOq0DHLr7CkP9AIWJVznZP1I2uz5QHS6H9EK/aG1aDON9/8rdiDUvvzwcajhBZOPELsCgG+YtBCw5WA6/AvIXnmCf9/OllViDKTpr6iAg8tnlL7fXb+4oc491MlI9Bu1/YuwGBZ8Av6VNjXp1kqNJmQ1+nvk6Src9RD/Olt7zrWaI6FkPbeU08WWnQk7yHp0/QXGCV1Aoyk5cO3ZEwEgGdqw5PTV7SuoRWaS6DXkqfFjxMobEjHuFBWGnPEI149S//oEtBhAhG2SlNEgOzgQPUkUlf3zkSsSGJ0SJps3O+widslWSS3qltXPM=" + "payload": "Aq7tiN9Et9emu49s63Jl4Eqbj4LF+lJOXsLCk6UV5mEmnlniZD3NRkKTjBtaYw1Apu/A3Vsnsjfd823ZPadszONyMiHJGAmKHHlFVGMplQZ/oVeudJODzm5+z5G1CFaig1HHFhPmvBo2z8+5UWXuEydYh86roNVd1jrAWjDMk2+19BbS0YNfGrucumMhtpBykVRKYyrCPL1ed7A6sVQGzQgSBDQX3v69xoQOFzhL8qbZqMiGrvRbdb11GVZ4t7Y4Q/+J3YZfm8p9j2RRDK5UrQx/ruNdijbGXAXVlvZcSMYvkzGDBsTlphFn8bCUho25q0wnp//NFeChwMziCi3x5uvdAFA4LWaYC6kvssLZMqtxfqxGiHJaxfdpAeFjU6vC1zkiAFSyOoVw6poBnGGBhXreFtrE37l+zANvfULMUhM0dtiF3tkrPcU0nY5PAaVZM55YeZ9R79x0sIfqHEHHCNJUfPrKN00heg0HS40aJNzg+/w/kJhxZgMG/jo2Gbm6+o6f+Ydo4fdrhuvOF4WS7Hdk4GfRiMrainqvXGWVMPLEZgMYMpJgJp5ZerxKuoGpXZpCYOkXDYeWtuli4BXOGcXxI1N9yIWxo21kQV4VxDm3ORg1cKMrDWPfXrrBxbiHgJPKI+slozeDULy7QH1Y3zHjrF3OpDU2V4shus+mexubXI5ZwJXZxLZewJ/k9eygNGc0ukqoOxlgIN1oCLuaVU03KqPnKr56SJ94ksbDNrpDmy4PJT3PQz/yozlgCw+U314xRtNWRjkYZZR8gS0F8W3ikrhA/DwmcDmbLDdiR5qLwq0ityOek+jk6nmJnWhOTV6/TpfLQCQEEEecEuI4APuJtNXxJkTXDG6rcuBa5MG4EUWCOG8t3qKcKah60vwIL8hi9CjYeUV1bWjKnV2+7pCr/dWYdJdVPkgNJWYa/MsCAG1s/PFR5l0JtG/ul+VFX2LWfOlEKI6iJ4SDhjIj9YA0BO3jwsvvMoB69loM3twsUco9ZNTkLxKIKqAq6ynij3Vl3NFvjJ6S9cFFUmvwgaFRNdvIPFfitN85SJOHop+xe8vG0f4gUbRnlZxWc3rx5dNtiuuTCGv1akU/wC6vxswvUxC40sK2iOOKyyXdYq47wtcMX+aX6GgysJPeZcVpqI7Q31WEj73naDEOnGRyXNa4T3A+zMdpLbYMdv4vXSVSszwRKu/J+OuA1NI6t/DiawISvHwcJz9H3ir7QelinDGl45stkJq3T1izExD8RAue73W91W10uvotBM58gyY8YgJaJmhf94u1ZVJblwKgzsMIXLMhT0zzJ4b7fexGqp+HWCImvfdqgRjwZ0pQ2nQnAUOUHbifrB7uo0wEV1RLRWlRLpfPbhwqR8ycElrERBiEq9g34L8wxtrAIOyORiKskEIABZ72QZWCPubWHt74SWy3hTEcuKAM9ur/VCQGiEGZVYE=" }, { "length": 4096, "nonce": "848b0b4d876eb289d0888fd9ed35da95cdfd34e2fd3de6e72642df24d88c5aa5", - "payload_sha256": "2c2d94e20d78e0731a34407ff0851ea4c3b7b7c60eafc8efc7522fc4c13ce06e" + "payload_sha256": "5bbf5ab93d874f4124525076fc34104d29d17fab08e0027f5d00a52a0b0675d0" }, { "length": 16385, "nonce": "7db36db2f88426e9adc5802956bf00113b27e9c8324ced1257ac8ce1dabe323f", - "payload_sha256": "ff10af665857b809b17f651c14f1a2000792dc1967f5c86029e54a64c3a85630" + "payload_sha256": "7b0fb7b0d35f3eaffda69f0f286f843db70232059c44c6e3d9e4b7c1f9879e67" }, { "length": 65408, "nonce": "73a093dcc5202414c2a42edf10400e6508869b5fc44a607984c9b27af6d469ba", - "payload_sha256": "ee065e785925a716ee5a5a2423938280f4e772c899af04fd8c94b172651198c9" + "payload_sha256": "3e4041edce1fd12eb63c5006526e3460f6c3c3c2127d9cfde812848d2dd13ac5" } ], "peer_pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", "peer_secret": "f5802d7def95d950fdfda4bb3e4c119769b87389eeaeff80368f787124edd057", "proofs": [ { - "proof": "707762b53e6a3c2ced205b1cea51a26c845608c4e2a6e42240f17178e7b661d6c2e47e5e5650dca54d5cfaa21830fd9730a041a776589413aec4cc3ba730a1ff", + "proof": "4d968acd993a4b99444707214898846264f43df581cd25bfa69e1a2bdab4275a72aa453c79e24f9409edcfeddb20d1c14e58b2e3ecba89131c9c8458b578543e", "timestamp": 0 }, { - "proof": "c015df0ea8d3777f90763b343e89e019444a541350412c601dc677810f064ef8b56fe73d7845ecbe30405971677bc59112e72f59f144238bc9d641d94b83f3c5", + "proof": "54821ec5873d23ed72b09733ef2da0b29bf1c6b5761b7e8ed27d0a813a71218795f80e3b2c93db1916c0f52b34757d5b079238c475019a76a98f3f221fafb03a", "timestamp": 1700000000 }, { - "proof": "962d6977b0d15af1d4375ce123b91734fec1b2c478122673e4159ad3ed53bb11deea24676068f3fd17c74fcf3f141f9b4d2fd2db52c22fab50c4cd94a1cf9f0f", + "proof": "f8eb6688f4012c55f36156a53112aebb194304ea854d0f234ea12ca8dfc04107b5701a224114f9738db203f85a6fd207ef64ef6e5363eaf02b5d993252ca12f4", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "7cfeda56480c19a225fc4eb9fd8487f04be718ac8f0afcc7783a96fc8a52ce6d" + "transport_pubkey": "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4\",\"share_index\":3,\"verifying_share\":\"02f3077e869cc5be3a3374fc7bb4b076700b2b8d973218145be36a8075dbf314db\",\"proof_signature\":\"90b1db00f7605a7333d619badf0b41280f72d25effb70ddc1249ed2dd3af321e0f3cccd2cb3f8dd9ec1e5a1279b48653057f6c62260ca2954e3d11949ba2ff95\",\"timestamp\":1791465432,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", - "created_at": 1791465432, - "id": "34571a6916176e75ae6c3a1c38c01dd2c315713d7e8f7e1ac0ba8284fb086883", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc\",\"share_index\":3,\"verifying_share\":\"0274c264121e801f3b609fb8d44dd19b4b63408609154c7750d4e6c536d59b4a9a\",\"proof_signature\":\"86642408a02d6a172d2013f5c2ff35e26c4f9adb4353b477f7d5d25fd6a2414af5905d6e6e8604d4b83afbb1cc0c8869e835aed8c8c4748226778b1cd7556fb7\",\"timestamp\":1791467350,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-1\"}", + "created_at": 1791467346, + "id": "21f3e307e9c8b81dfa6d7b0f6af5a4d5035e2b69599c39c7db7ddb0cf67d2163", "kind": 24242, - "pubkey": "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2", - "sig": "df9da4aa0d9649b560c540744afd8d013934723973fad58837ae5fc27b8ceef3d76eba08d329d69904c198a17184f693e309c114dcd1f714c51ea7fadbf41335", + "pubkey": "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d", + "sig": "55fd84e1bc8f853de6d396c49399ef8b8bbe8358d5688320f5a8daa8a4bf7bbbdd96eec449fdcbc563e54478172d19af4c5279b5e0ab5cd9590d94551efbd058", "tags": [ [ "g", - "a38e995c03772a5def803da76d2fd12bcc9cdacd011ff861be19dce4fac228a4" + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" ], [ "t", @@ -873,27 +873,27 @@ ], [ "p", - "e76c7a6faa1386b239979bb5f61355ad5339b782170a5bd296284809eed623b0" + "0227fe07fce0572e529e753cf4e0eda5b56ee794919639b42b2e42d68e064626" ], [ "p", - "19fefda587c2e26acfe3b3fb450219daad6ea0393d2279340622cf4e46525e14" + "178fb6dd67b2eb40c29a0ac53416c5fc9331aaaa35350ce9babe2820311efbe2" ] ] }, "events": [ { "event": { - "content": "AtnLDH6lAmeQ/voDwbFkNF3qyZ9dbTFD3pXomkqKg3izEg0oPuYpeG8MsgBuTugYIL1kyfYkUvoP2jkFjjGzLRc5GDlwWM4ElZwUT4AmywSTM/gGtSnlLkbh0B0SnGoEA0pXBH2sYk/VGIzt9J7PJbsEFmMFsv6oQiEXFC6gTHtJP0g4oiIX3ThEoF0FrsENprArNRlqYufi+zTN6Oz2DT43Y7+PbN2EOOhSir3618/B8zaRPw6IFmMekMSFUBMXIor6", - "created_at": 1791465429, - "id": "cd2c35ab61602ff175b13ea588c09077abda06041fcc87be0167f3201e125e10", + "content": "AiXULte0WycUHT7i3Z6gb1bEqpYfjXS18Cmus3kfOGchXsAo3qV3sITBXbzixjDoM8xQdZX07PYVmuW5mi1sCzxzczdln2uM9zuaxMh7l8vxcWvPJ/maY+AiCQba1Iu6lUGB9vkIamJ++4Rik+A6IK2YIRjNfy9fN6gCES+FPJNnzRCgnAc3k5rD82v8DoUykLcHCYGRvPMxHtC4NW8wmomk6IcuE82fwbtywZ0Ap3KeEpNu0xvMmjTJuwY+tvgRTRHg", + "created_at": 1791467346, + "id": "6f5a80c8178a9a59651c67613a92daeb280ed0ce0177e8d1b4fe03d1783b12a0", "kind": 24242, "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", - "sig": "8cf7a20e90180896bebc81195ab22b857e92b3a9af30bf4a70850e9c26ae35de8f57d68a3b64637b7dd93dd6ed68500cb93dd03f4478435ebceb0b1c3640d9c9", + "sig": "430c4073bd5ef7d3d6b143cce15fd6db9e5c41e417b0841743886e315fa5edc51157e4aff446b720e7dd1bdbce20a667bf1fca685cf6f9f237e35aac7d6c8627", "tags": [ [ "p", - "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" ], [ "t", @@ -901,20 +901,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" }, { "event": { - "content": "Au7DaR/pB6N568/wNCOSv6Z1deraA3i7gSdcvexrH9Xz6bkAgC4Ef/JpgVJBI5yRSjpOmImxV6EoS0XcW5D/TviU1feu4RXTkUfSdJ4puWhRJfJCBtqgLNo6Floqhpy6EMTR6tIkrFqdAT7Bf+bXL8r4k4yr0owyUsX7VuzBr3MvW7tGKOz9dLZZgl+wdwzAgzzLdL+FaohpQJP98nSrmG3Eirgq/+IW5ZgYM5mfEi/9yc0scyyzl3B8ataUf4dtjjKe", - "created_at": 1791465431, - "id": "e50a333b6801cd5f892b58c55b6b639e3e03281ee6aa4ac1619ddacc6c5cac83", + "content": "Aqk5evV8FL128lapz7WHCQaCRCY2lpIVEYEMx2bqRZRgrUgsFW6hpJDZi+HxvDtDMIon+WLpttirGW/xkAO7yZVAzqTf+jO2VuEXpyXTL11UQbB5ojlhoHtDrRrrbwLrX7jID6WJmpTqKVbfWyriYS0iHxCcKwUP9XxwYw7+V2mIakLURPBNP1w7WKeWxz5luGshTH1UQivaTC2aTmeRkYvFl6orqhmoCDSSPbQBxIojq1eVLBZ999RC8PAmY1Mqd+ZN", + "created_at": 1791467349, + "id": "dbe4e339582006148742cfc3707f6202804d0d0106fcce8cf3afe7cce8e9ba52", "kind": 24242, "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", - "sig": "77d2cfa45456e28622bc4e8fb5a92f0b49acfd48b3bb2be9f06d2c8f800ce75dcf67abb46a4c5a376725153e3b5f8639e2788e830996604d0accc7c2daf994d3", + "sig": "ff37b0a8113aea28aa8b0b73930b8f7598ec3f3bb1177393ff98f879ba3e744d4f05f69dab5303bd10f9a11c3e77e6a2a51fb4532ebb74559b314b09b53647a0", "tags": [ [ "p", - "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" ], [ "t", @@ -922,7 +922,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"d560c5dd47faca6961ac555b59674182815c1119462abd3e4b5e435e5b4e5d69\",\"timestamp\":1791465432}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"c4dbf61ebd1b4977e586d67d70b7a7d6a3893a8b5a2d564e8c430b674d41fafb\",\"timestamp\":1791467350}" } ], "index": 3, @@ -930,122 +930,122 @@ { "length": 1, "nonce": "334708a718be8bca0387e6e40f125415966c68252c00c6442755d9a68b041d07", - "payload": "AjNHCKcYvovKA4fm5A8SVBWWbGglLADGRCdV2aaLBB0Hc8FIC/+iZDnvrA3PYbHZPlXXXbQWkbdA8tNfMF0fiDQ+nPFh6Y4XLatabfBeac4hp9wYN7HdjcNCHq5EZbxYEsCS" + "payload": "AjNHCKcYvovKA4fm5A8SVBWWbGglLADGRCdV2aaLBB0HjRi+s7d/Z8TUiIVATMMfePgqQjBLYk4bJyUNgjadQhKStqUGAoWwrFVnEJAMZgH+lw2EBoS5oirinJY8itku39jX" }, { "length": 16, "nonce": "fd8634caf4d7e7cf1097ca12e3da159942d9bac841e01ebf63b8b852f897d004", - "payload": "Av2GNMr01+fPEJfKEuPaFZlC2brIQeAev2O4uFL4l9AEQFTm0l91hgN72jwD50wgCG0w7kiN6Cn/zjBFcZpvOb1vpVKTcVTXP9oC5sGZsKhUoyFQM2XbCX4krYgsaNtyXWVk" + "payload": "Av2GNMr01+fPEJfKEuPaFZlC2brIQeAev2O4uFL4l9AEt41FPvJS+OFmX0Vt2g5W/KfwntvB585Zz45RraLMOkFItAjgoEb6hzGa/WpnsH3O+phKVGLpkWn//7Hl0GzpS+zU" }, { "length": 31, "nonce": "da33ab3992feb836cf1fef9c350863fd18785f7eab53ce40809aad4bb0234323", - "payload": "AtozqzmS/rg2zx/vnDUIY/0YeF9+q1POQICarUuwI0MjXdDIVKtEIOR5uchIelgLrD7spD5FhUa6kYOc4cjTcvhfgTpishRvQ5Wg5trOkTDLYNgLFsa9KwFIiWiX+VGk0qLR" + "payload": "AtozqzmS/rg2zx/vnDUIY/0YeF9+q1POQICarUuwI0MjgsJXNQo37BzzLKKjr0ITp9v+tk72zYW0RT2f9YknoOEw2CZcy65bqksGs1UtaIOkDVlR9yBiQ/2Dg2Klmb/vQzKL" }, { "length": 32, "nonce": "38ebd2c49e44bcfb0970bc8b42e140550b64ec743ed035552bdb00165c083193", - "payload": "Ajjr0sSeRLz7CXC8i0LhQFULZOx0PtA1VSvbABZcCDGTsVvvNmP2pHG+rIYuuxdaavA4BVbXqx7JQ9AVaoehyifx154Dj1XGhsK04TKrdSLrYBlcFrCp8Wz04o2hnP9nrvGk" + "payload": "Ajjr0sSeRLz7CXC8i0LhQFULZOx0PtA1VSvbABZcCDGTPAADkkLK2EAbObPrOCeJusCKKN4egNdZ9YrEnh4WwxQi+S1oHEEyKYvEWEJ4utGLu1M0G916LI5MXhot8RzsA1uT" }, { "length": 33, "nonce": "6fdc2a52bf5e73a461d2831cb4df48f4a32caec0b89fd832d5c31cdab3c85528", - "payload": "Am/cKlK/XnOkYdKDHLTfSPSjLK7AuJ/YMtXDHNqzyFUo22InbJo9lwKe7u9FEAIsPmQ0QBqSlaZfkiaEOoex6e0mIBlFp6Y8Zbw3EgjS+i4MIUVRdnEDQOmS1jgEFeYG09XFkVODSxGgq7emTSK08SbfwUB/nh1Jx5vhUX1hWIEzSWg=" + "payload": "Am/cKlK/XnOkYdKDHLTfSPSjLK7AuJ/YMtXDHNqzyFUor4abtT9aN0YYCP3y0HpV0bYcg2F9BLSxjyL1YEkTY9zSL9Lx6mjLMUtyEKJlkvQnCzgMT1z9Fu3zLL2jShmEMfLNnZVcsZdUjVSMLFyX/xJjw2n2mJDfqW48NKA/s/Ojw34=" }, { "length": 64, "nonce": "cbbfe9170917f2681e43ba1bb2908356b5ce4a774ff8eca7e8c8d83026b96306", - "payload": "Asu/6RcJF/JoHkO6G7KQg1a1zkp3T/jsp+jI2DAmuWMGSKjJWoG/T6SatmlQm0kdGw8zEa6s7jXykp/Ewok+FViOnIvScYW/xk45vWqFYiB8nPUVd0/mnrKEisPqQeIYhNsoJVDlmsJNEv/1pLUMRe2ukooenzihhpHpCB5nd2CuduE=" + "payload": "Asu/6RcJF/JoHkO6G7KQg1a1zkp3T/jsp+jI2DAmuWMG5wmrSiyPM5pkaJjyestsIIyoRlnO7P8nyA5Dhxl+cvr9lzsSmHffxbdun3NYg0CzRT/5nSHn+HVSxP6G80tWB4oE0Nl3r+1TfPqkGbjRCuIxvLGleOn5UeBfRAtA2g2mZQE=" }, { "length": 65, "nonce": "62d5a7e4d36cf67ad1830c359d2ca3848236b5fb9bdaab447e3d2f15902bf1dc", - "payload": "AmLVp+TTbPZ60YMMNZ0so4SCNrX7m9qrRH49LxWQK/HcwBJRLGAM1oI8z8M4LL2MvxMi1xMBIcd3qPqmIkfbZqMfsk0gI43X98dY+WTvLNJybDNWCPwEs1WTmrC0fAxuTioxL0Z31UBSafAXXjqGxOF/Ha+Lx0e+dhgvaIQ83F74X66YzqREvcNe12Z1qeNMKw1UL4Ez0ECtrM6FitPx8LPs0Q==" + "payload": "AmLVp+TTbPZ60YMMNZ0so4SCNrX7m9qrRH49LxWQK/Hc4/7gWfIHlIxnM/ujXkH7SjI7S+06Gf89YV1Z8d/7Tr3epPWXtA+SAq2NzUuBxBekBm9fai1KE4ZTuLZfudtWLnjhqSzUlAtFHGbMPA9MlmxEeC5uQiHYd165WUWZfIRHxbdEjRQTPYg+7oFus1tuov283Aoq0Xbm4YK31CpHLreCTw==" }, { "length": 255, "nonce": "7ad8bd9f0730284c3bc0a20a413b739aeee516484df65eff2140869fb38cce19", - "payload": "AnrYvZ8HMChMO8CiCkE7c5ru5RZITfZe/yFAhp+zjM4ZtLwX7znP2d2YYuDHkfu7DZSA/RqBf6+MHRmnur9Xhe5ek4fzU/qOSoJ0ahamFObpCuQhVaNkE2KyRLVqf7/jUITctGjQdX6Q9iEkeVgslSneAEk0QpVu7f5VK+8d41xA3WtmB0fzStNYiIkyWJ+77GiayZbXCO2dNwAG6X/6SXzdAz5zOz9U594HUOdI+q/fqx7w+9qJiwVR8o2obsyWvENgUNC7hNSkSHQ8HAbM2NAOWa2xQY65Bg7L9X1Q8bZ85omuH8w0tiAoluEGnOv0QXWTKw37xuK4AqDOmrnNqu3ZTCAWdfQ9IooytkTWhtk1+Gne4dIiIRwpSNjD7kAUYbV2IC2YKvvbz/ApreoTD3r4IIgKdScmNrVVmZ8qW+3Qxhg=" + "payload": "AnrYvZ8HMChMO8CiCkE7c5ru5RZITfZe/yFAhp+zjM4Zcx3Z6tINZ82w/mrn+I8AEvGzB7OMDaCwk2/sy70i2HZ5SUzD47qWZGWt6Tgt8DnZTuqIKCAKXJxeZoMGTiqQAaWY+juFZHHmagD9F5tpxVNQ6L6wQIgYtJwsR8Np2FGm+O8Lz42HFIYEVnl1/um8eet450K05OjPRTGhvvuvF5gDzk460bDwGjxN6vS9U9nIBShRTyhvRboTKzUlbSvOWEMCKtjDP+qeo8DuiI10aHRmRQnG8bJrxLhl4DQt0aqMcXc6DR9bFEC3+nI+KOQzmmpcA+zVm4PyjDfaKH8Znty1/4nu8egw265WcyM9UjVA9hGw2ktH3ZdCXFw1KSQVJ43xt6aS6OlM/LRdZe2eU1tPChcXuqG9kgh7WIR7JpVd5b4=" }, { "length": 256, "nonce": "20994034195f0c00f465b8a249a57fb62386b061336f7f62fbcf585eb98e091b", - "payload": "AiCZQDQZXwwA9GW4okmlf7YjhrBhM29/YvvPWF65jgkb4Au56BlC78Fg1o35nm2C5EkuJWUevUn5btTTJRYhNENheKKHWdt6qWw0DI7b917iAMRNbw+CzsVOYZUt2WH/LfwXc+UR1Idd95vkLmEWffR911anfGRg2RYpY0UD3flS309bKrt+K5oG0qV9aCLZ5hlki7RSD4U1VAB20Eu6VIHd7hVMxcxW6nzqEZnco1h6WZnCKsCcQbkou+R6Pr3f5FXzIuOIWIfb0+B8vG7idznhyiu8S10Y2I8f/+89nM2igFWJu29bmV01aSjzZC9gjVrkbdo3XRu2tGeYyH1QsraeJ8eCnaNgJhkavRQS8fvbJ2REErh9YmToHpyTuAITkzETD7Bd2dASVmr1A7ggFlA3ukKAPM28XkbZ/X8iCP2m/y8=" + "payload": "AiCZQDQZXwwA9GW4okmlf7YjhrBhM29/YvvPWF65jgkbspWYhd1I/lGTyVzKspLLojGVzKxGX9mHARUERLg9BWDXPOul2ShcA5wYQbaXSQjeytBqGjzW1BySPoUVa6YvPH3wFFOXn/IDWNIekgucrBoYreqa5ej805g7sqKN18rA2MSGCAf9c2nK0bZhBQ60VcoLISSyOn4LCTCb6auUEWR07Vmt1Ra908nO+gZ8jPml4cn0+QiK0FsPYTiHML0SkVPNs31bfpPb5pm4YBxoEsyGWiN9QU/4WofJYs+QyhIXWQJ3y7YCO1Y1DAYO/iFKv9iyfp1ocOv3QRy4bJpTEB5c0OFnoWcanNDKuHjHAWG7BAuH4l4EAKa6VK/nYA+sNDOeR3dpAA4bQmeqntMVWny8aWfS4MmhM3CcHHVMu2jortg=" }, { "length": 257, "nonce": "6f846db2b1b3306c3c62c85df2d2a09a043eb361a08b1a641d23405dae220690", - "payload": "Am+EbbKxszBsPGLIXfLSoJoEPrNhoIsaZB0jQF2uIgaQfuEULYwFJIhxlfc69Y2zR9JmtmiAdoPa5ZTOgkLx3RBSZrETfsV8gGq7KsZ6qkRb8494g7t4npJZH0au9DMDi7mjElekRU9sRykwNoHxjQr0/mdujzcvgeJUxHGix85+GjTFpqA0HhkZwdaoutmoH9TdJFry5zAHf4kAd3JzTja3Qu0Dk/Vh7YOJl2+JuAO5SoK2UbM5FWp4H7aNH/gKtfnOfQLGqQf0KpxkguSVhxMyQSh8gpi5t9668BqJsOdiERG2mrFHc+aXFzSQVRAIKbYcIvbIK4kp4ZmK8PcRTFOfFjfb86KvAhFedEzP20fVu5QAqmcAxB6MVEm8tDmWY1KX1CvsCHmHJn5vD0otqDOt82CuiTVXkFo1fGO+0SUxVn3osi7+//jRBrPsQb7eC3wHfxyBJmBgWXjntw9O4zgZnGfdPIOuZ+lANpAnTETxGMDDcJJydJsDfWwIvegBAxOB" + "payload": "Am+EbbKxszBsPGLIXfLSoJoEPrNhoIsaZB0jQF2uIgaQxWhd7QDHrJm7CP0PVCV0idVruN1tWMrJdUdm9GIxCqWqQNOEN1vd85/z0f6Y5ggor9oabxfDF9GwfWZEGuDM8wnvv1TgWVbV4iUXUtCDL/8oX0u1JsqlDkh2tKs7xqT6/oTTZR2i8WJl/7pOej7FcdVLiLvTRrPyL+pUbBDWIvxJIOqPT9MKDCIzjNuyQ2x2M0tzucnhc1N8ThgAS3Wcf9LGIROZ89+ynVxqH15SOxkjywYnVDDyOnipjUPLMTQaNUqmv325y5uDG5QMkGsJibzE8mcOnEtPBJwIQlaa6rfebLvSgGd5dXUks4CpkVjndvmOILk4QTz201JKkP6LrRkCm6JxJfd8KZ6jWPOx4SXypsSuSXaGsMdzbEvgT6l7UAVoBQj3o2SnmO5ihvDJ4Sem+NmlQszDa6JqNKBSQ8C9GgCYfErPxYUk1z2xyV+8aQdkZDp7Hp9cCZGWMMKr8v0q" }, { "length": 300, "nonce": "20759fcd458f324ea753bb352a6530e693b415364fd51cdee922259593b32b63", - "payload": "AiB1n81FjzJOp1O7NSplMOaTtBU2T9Uc3ukiJZWTsytjJq1eJGVkRj2VUvo7m7YLJhFkN4jSlFLmIj1GwjCDx/ucruqw9mR8io4+iQgJramwinRuowk7Ckxk7+kEH5uj1iYj1r7hSY1zvN1DdbCXTQy8QFIk2/JJWOqHHD9w0H8/K6A0BBuh0pUAeEcmal1iVMy5YbWRT9k9Fj5gtJBdcpNxPwb8EJUc1zgboh/2eMwp5atRQ3y9xRop1ZS6mXfPwvqXRZACbI/fIGY0yFqr28K35YkQjOJ7Zv7kBqn4YFLk5b9lwq2UCjwrPL5ZUHt2oclyiBobl+VKnCWdA3P1BpNykVW5pS41vCOSXETXFDSVRTjgKCeGlYtTDAkcyFQMA5te4NSafXv/sOMYsEaS/WSmtD/EfoT9AX8eSaLMMVX2tA2SFD33l9RvZTC2K+ij4/X9kmJVZKMiZB0oTxwNTed5XlBWPC6LQTDXaU/Rc2jP1v4XaYZs0wfdZPmGtIyXAoCm" + "payload": "AiB1n81FjzJOp1O7NSplMOaTtBU2T9Uc3ukiJZWTsytjUEHjF5JYUwZKjMF2O+IRw4k+0Y9I9f44nBpsuvExHDXvn3XhKPe7eSzTMozGBo8l3WYFFj+vMbndkB6FzFQLbd0MWKkje6Ei9aHkVqsc13PblP4MYj2nJrSltF6lQ5wo32TIUmDhqMle2hpRIsudi3Y8Ny4g510j731sZLzDgxXbh7cV7jaNzj48cl7zetEYUdehu+4XWtpoGBshpkTQIQX4987UdDPyAkC5+Sv3sK8hXTodmbLzZ4kuR3zOx3Sqe+GEO18jffziaG0DD6DwMQFfpeyRCcWHfSG6XhszsbowpwbcxwWUz690uItyqCtfKcSAUwhGsIwVr9CYUYC8ZGcaETl8NERHMNfbw/FzuijlrCGPvNRFcfIPBkvHtvL2lWGGU17Df9okXL/W+UKPy/Qmw3aQuYHV00oyAe3h0/pvM6txt0GGuLb4rulmFh6euL1sg23yuluiI1wF3t4RXYrg" }, { "length": 1000, "nonce": "aeb1d67705157852a1c1c2f953ff70f5a1f5e6370244656ca8b2ed383cde2b90", - "payload": "Aq6x1ncFFXhSocHC+VP/cPWh9eY3AkRlbKiy7Tg83iuQKWPczavFKKbkEEyZlRgoYc9Vh30Sdd46PJLKcBmhG16eDeh/tAJVbD69F5ci8JO8f6xNLEtqp0EtBDHwcM+p1pHhqI0bm+SAPbOLq4PYC6B+l4fICj2QXLVo5AZtZLMKs5PeRvX0pkQqr8Ymkst+Oafe/9xpSFw+dU1z+Ix/0XIRhVdQdTichjOwO5und1KG7lz1YA5yMMlhAbE7sHKX2+gdVHaFSGGkoMC9jnDiRYFZnhzUM4CwOtCMY4Pc3TvPt3POx2ppE03X8RCdzo9h+df+iUDJ231uBs3O/mQSYDCuflFH+bmQUMOZQJ1hQDhbI71KtoQTLEn9EQ3+ikw/wDVVFV+T0yzOepxiCLgi+tJ2ydmKM+xBVKRV8YLj6J6yDrMh/nV9NzWXESTZhfpphTqO3xVCPu+s0FiRU2P8txjoIBB8lpkhLADqgtdI2pwMxrC+cbr6kikZ6Uy8hs4jJfOHhlvT/MzVJ64gKO7gNf/HAq7u22c2voMTaIY7utd2kDZL4w/Dgo6YfxjtjjxGQSwJKPG9rtgDyOjNCcB6f101NRIuSkMFdpjMOCuxubahZkLxYetRVngjlzRgm9ateACWLmvz8n8U9iBz81/DZH1/o2UgpgaIUr/SeB1X1iI2rPT1LzydkylN2dFnJV5kHcZLMcdHSR8oWrekdmi9DL/NK9b2SbX9oRthiXhuZgxQksBDwROyvSpDQ+2MzP+Wt4UHFfKMZ7vVxa/+hRIUJIPZbvCHEY+WiNoXqaY67KpTiS9BC0A3r8DO+qLG/TUd9EK9QiAUFJabnu/OGHJNNoNGAJMfAhhEBtmgjrnSjGGxJhuL9hXgh5Zvfv15x6RF3bJDevzHzVcTWJafg+IRtZzeOP7UXwrfzG08IvfnC81JGyj+bayBQMpT9lHOSh6qtIrl3Ri5DpqzpgJZrfokgZfAv4+CS+q3v4tQDrybN3/0hRkEzURRy/8a+KIoD3nJY+T1PiSwZ8PFKxWSauKAU5YY7yP/UYB6OESt20oKonObWfw+zSHqiEoCXaqZ9OmKhKPw/D7vQEu+yiSIK/pwThn9FONBKEP5xkD/JO0I6nIUj1VeI2F6V1dfaFxpCg5qYf/1WoglAI2MpRv4ht2DtYHpKKTvG+rH/LBbMegI13XkVPvlc31ezaA1m0J5SV2fegMcrfsp5XLvUK3iXh1yK7JNoKTJuiNTSDFVVkPw/orngV+R1ryTgYCH7qC4OfYu+Dyxstc6KkESvHTGw4x2O516YbqyortGm0YBWvRcDCZVPDn31tRwNFHktmFX/9ubXW69I5vl0dvTCToGSrxpaxgjUPWunF7NgA8OQ7WmdFzfuskOb7a7Wj6IH/UGy3tfj6amR+T4sx7ClqVvGoOofd2IFY9feca1SP5NPa21ZoiMotg=" + "payload": "Aq6x1ncFFXhSocHC+VP/cPWh9eY3AkRlbKiy7Tg83iuQoNWfdQDhhtlbypiUnFjr4Eq7hQrkUW+xixxLRtuw0Sx7GNhh+Fcn0DxbhP3yW2Vv0rwz5qYRt2ooBzB6uD+vwCgOXhl+zMnPYs9dWAkC/5V8KwyrhVYMQMYvDt8ICCEeu3jl9vq6KHGWmw8qMOE8/ymFZywXyph+m5vf0N+xBOk1/crhuy3RkzpTi7wzdhRlOh6nWyTttglf+BRKAlMgwdllmMbzWZ3F3E037jS31DMNAPKYl7DBHVVLIszMkcnpLM5i+Irtz2Sm+R+6O7SkkHiyjxbz2B0zhkTWqpcq0icptd0sNoLhwG8byFf6M+1TZ22N4950B82Ldhc5l5m5d/byPX92RUz+N0rQjbaQr6NCgqM+FpR7oYTX2bcm7Lo50HcmnPcAi3kLi/xOCI+HTIghAtMQqpF/ryxtDY7kU3a0JmrqeGwqCbbM9ZE0/vp/dVYq3haWU54w8y4wZQewm/7wfMW1aS1XgJDDFU4I246cx6yoPaDmhdGeYH4DYhp2kQRz9/NXHkJDw3iAp7gBEB7fmENKKyKYnM/uzGQ4GZX7fH+Pr4HmWZlRa+TdnVJmXkUQ6IPSYesCeNwJkySDg1UESYnL7ZEtvqPbZUDa7oatidBmDHnQEZLLrVV+XrTJPMxoqQrs7OF/eBSAYhKil5v8tBAJBcKkQGOUutd+8HHZ8+bdu3l63WAXGjX2zyecVHht43XMkbY4JMZMLjrrL43q28V50rGAVA8oYSmdIdhjT1DQh7/OZ5nm/KZsK9KVxRL9rfD3f9I13kBFk1q4km3Yp6LFYg7/qurqqjQhdcR212DTYUoClmvWAu9sZAZslCdL2nqpS6Pplbl2nvlEJPHnF5pJcrv8aYD5l5h1s3KM3IU/+6ZNGgqcfePyQkyLwTQ7JvOCIBACDOkYpCLCd7JrSPdYCw1wbf2jRuRoX+LWBZ8jRjbW+qJf1m522PWiQ+wwBWey95EH3AJjtckLlVN2qV+rJK+WXkgZavv7jgjcAsJigdukzrQyld0XIpS+jHqkylqVmTH/9Lusn7Vgdlqckior/Cv3Dal17Dp9sMKh7rKGDMe9wRrDw7Z9CeT2AzYAfx8UW04QqF7jcnO7n9dmXnmCc4hoOAWWjxIRc6aWhWCThpNj6VBLW5vNhuGHq02fv4TNo5txzFgHvkdjocuI/EauGDHJVxv0A9eK0CF/v0bPY7ZsR5qOQyJhNdhBQcaTBXjwFixk/FSRFo1ThKnywvLTLSlHENJMHt7rmXbFjd5iN0IxElzJBXTTrjCO2kbFUhBqH8nAJafoviT1XMCQevVJKOoWMRx60+YXzAgOimn5Y6QwPxCBGt7zC/ToQ8BqvNTLu6k+NA64RqoTZCp5SsKRsH5KZAimug6LCLucR/psQKV+GkIn8zv8xFS5gPg=" }, { "length": 4096, "nonce": "6a40e95b8496867b5e4002f7e91073b39fa6f9ad3c4bbb42b8d9d3b8896be991", - "payload_sha256": "e394e886cd9fe3bc03ec8f75131836e4ec1e45d71d7836048758ce0d138158a2" + "payload_sha256": "06856ab277e98bd33a1cc32ed8a2e0305cc5be2b5c1bef91f490bb59fa98585a" }, { "length": 16385, "nonce": "c0874facd941d2710768ecd778c7fa2a4a11047815b34bbed71d3a209a935815", - "payload_sha256": "3f475443fcfb61c8993b3df279f09655b181d5610a724522972f33ca1340cf09" + "payload_sha256": "8714a5763177f031a6103d9a3494ca4f1cc7bcc5e6c72146412a18c00e5c2223" }, { "length": 65408, "nonce": "dda1bf189af214614c5897f0e262559ed8de6aafab903bbccb83cd4c0922e485", - "payload_sha256": "b0a1bd6829dacfc658674ab528c764ec25a6e34ec1fe864a532a42057bdfb056" + "payload_sha256": "755955228d66f9f28c7dd3bc572d666a4ff408550e63c3fa03c6b716e7d6ce80" } ], "peer_pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", "peer_secret": "51a6b2c6980175a00c531d74bbfddffcd4bedea4b21d498b6a88c6785523eed3", "proofs": [ { - "proof": "f1f15f4cd93f3d6a46af02de587d48613ef2f3ea8914400c18a067d38cbb8a215b1285033daa06b1c8cc3a5b6cacbb83de963afa7143abc8c7be84ff39fc4515", + "proof": "269850f7df3175deb2996ea53edc27143927f93801348619e3f4a4740cd425ff1e7e7b10ec0608116d4d7cc3d661439f92cf53b4382395e60dafb739ab3ef559", "timestamp": 0 }, { - "proof": "9cfa479d4edb6b44dfe848eb06c28cadf41652daf4fb822339a4f35ff6742118d7eaa182a3a84f4e892c57a371c711ebedc938654c5361daa94d6b8f9137cafe", + "proof": "d26774eccb90b74acb2da8df540afc7c09debcb07e5f60ea69ea326c7787524e143f6da27f40c1376865537687b261d95903deea36a5b5f76b26592669a0dbb0", "timestamp": 1700000000 }, { - "proof": "0dd451a6a09a2a5f491209ac970671300d154527286f379659390510281690da66fa19444c97d84f467deedd7fe6159425642b672140dd3d03b851d17bf432c6", + "proof": "192ed7db9be39e3647359b910ea2e779c39b122809372aa6eab8b42c633da0570e0da258115cac43f98719e485a25e666f7f4df3566a74a214a6e982c67ab1f3", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "ee95493ad78b83856386e313aad70fb1c821367db4720accf615a4068537d3e2" + "transport_pubkey": "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" } ], "min_signers": 2 }, { - "group_key": "02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d", + "group_key": "0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6", "key_packages": [ - "00230f8ab300000000000000000000000000000000000000000000000000000000000000015817335811128ed1e6a7d552529dfd60c7ea131f5fbbe070b183721b681d748602a02b046a5c07f0941b33c032bd13f72551bfd87976daa8b902cbaa7ee4a05da502487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", - "00230f8ab300000000000000000000000000000000000000000000000000000000000000021881ecab1bece4f3087a421548abdb1b4d658ca8e723ae1d1a22adc8f6dd05c903b455ad8e309d5a4f49ef7ef9c03ef04d268c589d6d8d3910f5642618852cd04b02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", - "00230f8ab300000000000000000000000000000000000000000000000000000000000000039975729f42127b22a6fb7a7cf8a03bce1188e031c69876ac7150edd13b3e09f103403a4eddd79ffb0cbe53a13602a8cfa4cd0f36811cd05d7c87176863dc07ce1302487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", - "00230f8ab30000000000000000000000000000000000000000000000000000000000000004daf1c53483835160c22b7e89627b1f7a59a530d34ed199e2f73bd3a7650a3fbd037887eeb910932a9c7973446335c1fabdb1911b0e833dd7abf944ba84f461724b02487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03", - "00230f8ab30000000000000000000000000000000000000000000000000000000000000005dcf6e46ae03f67ad5a0a4e3a863c862025ba7e8d7fcf17c0abe35f4b7441a72d020f00ab70660c72cb08df914e45202c59819af901044bb30d882b969a1ca325a402487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d03" + "00230f8ab300000000000000000000000000000000000000000000000000000000000000017d77294395518b94f6bbba8f8e11bb829b125350e23955e749017f26cbfc2a3d03fa5672c18c8701c65376ad0c4cd7e17b2f345623047ae9a4324adb4952fe2da60272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000024f34f112c85f208d449aad753e07bafee8f39424eebfdd8eb689ebd2da69686202ac88e83996019081807cfed4dfb726dd24b53eacdf27ee911cc134143cea29f70272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000034678b54294c8a2e84a6f9298fc3a92d403591f8da8493c6340f5ba1c6b17500602c9943ba6a56c33ebd33a8420f1afb013219ac5ddc825cbfa521b4966362e469c0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000004634275d2fa8e12a6083a69fac8aa4301ea42f58b0ed57264e844ea037e05e129028ed3f1022a056bca7edbd0e3911ec6d932b8a00cb40765f45ce2ac4b307e16500272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000005a59232c3f9af6fc67dfb339aa356cb889db1161d22647f93ac777b8813351bcb03f4d941d419d4de23a1dcdc76431548e0c694b90f4d5bf13a41e0aae0b35270cf0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603" ], "members": [ { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":1,\"verifying_share\":\"02a02b046a5c07f0941b33c032bd13f72551bfd87976daa8b902cbaa7ee4a05da5\",\"proof_signature\":\"9ab13b23fa0875925c59e18c13766126664fd3fafbc9d1d36022a7dad4004e242f5122f8839ec720f04c04a9e42faef82a37b818dd7289ff568442a4915b9b33\",\"timestamp\":1791465433,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", - "created_at": 1791465430, - "id": "c46a37f295217b3b7644d1a537335d5ff874ab48d4e3db4c331dc64b060dd03a", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6\",\"share_index\":1,\"verifying_share\":\"03fa5672c18c8701c65376ad0c4cd7e17b2f345623047ae9a4324adb4952fe2da6\",\"proof_signature\":\"1e38609d1518f6e0d6a6443e64ea94154a414b4afcd33a4b404983231800335b2ad2626213e7b4c94044d8c14d4ba55002a4f1512e3b2a7dd611a7839baf27ae\",\"timestamp\":1791467351,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791467350, + "id": "04aba76b32693c613f9598ba023d860d3d30e90fcff3e6f0660c2453ae0bd744", "kind": 24242, - "pubkey": "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c", - "sig": "0ca045e654db6941cac1a588db2bd97f9607f87a99e0a6acb3ae7502733e656d0518c555fed6ee107f1209ddb2a9d3f7e28c1a14a4af0e817bb1d574c300c8e6", + "pubkey": "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2", + "sig": "df335a68502c2c6181a5d8f3ceb58f61826516a7cd1aef33a2fb5dc4473d57e8d252f823828b14c14c4124d097cb14121d2fc8cf2cb6c293744a0b2e9fe21d50", "tags": [ [ "g", - "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" ], [ "t", @@ -1053,35 +1053,35 @@ ], [ "p", - "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" ], [ "p", - "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" ], [ "p", - "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" ], [ "p", - "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" ] ] }, "events": [ { "event": { - "content": "AuotT1raNoWzq20B6zPoo+h/YaJbWkvVeUaQr5lEO9dENK07UTshYu7gRKUqT9pDtLJD2ij1xxid6YUVabyEoHloxnbOrNJ91wSB9QOE+0biPzldT6fVuamKktC6ug7NiFxwcKy3BVVRgKp3ptQnMhcY4iTzZZrXvQE4wc2we6hUZzdNB5JXKmmb3lXkzL9VUftmR3kp2o02sEpWP5kwaFlSpY+sf7cz6p7oKNCjLDaFLp9CiD/2LU/1uMxisHnSiyYC", - "created_at": 1791465432, - "id": "fa503ee84f39010295fcf681c1a040c82e6fdd399ecfb5f7dc2e1de4244f1ca8", + "content": "Au9nY07pnCqNjr3uaZiBNiWCJz3ZQ2TAX1r1ciR7XOvtfvhSTP55Mqd/tfooIUfNS0oTSLGgjrmInkBVii1LT7qf7kWvROITCuMLevambWUf3Zs5/zGxT1/p7aj/CtPPvxSNMZwwy4Yo28ZrmYNOdLZPnup8P3qiR8B1Pl9B87S6ic3/LeeSa21bJp+TGRn39hb7ObAg5Usq8BluCf1RsBhnmQmPxwxDffLsg3prvLnI0cSU6mrxEh5w8wZqewur0m5E", + "created_at": 1791467351, + "id": "2130f35ded64cfec00de339cf22a10f8f036b0702918a6f9ad8c8fe46e5aca22", "kind": 24242, "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", - "sig": "200135f62e5721a8b7048133bc25c91b8b93d631cb2ef57b3de5b7a33cce039153820b2b38adeee984a73e492629e20ea71497a09a927c7d764f7f2c72c3d6ef", + "sig": "5838443285df13833203035670acf9a1f8a4efc7f8b2a6437e0f9d71d681e00ba393118db15afbeb17b3712d3f8a4e349f7e7d10311249094d3716a904e0af73", "tags": [ [ "p", - "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" ], [ "t", @@ -1089,20 +1089,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465433}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467351}" }, { "event": { - "content": "AjMvpJ+zSO+ZQvuz4yazYMqPHpWufC1UaH9CdLhs2OVxGOdPqNrl3jTEh0dpg8X9uqfRGDMKWdmzR94BrnlvSgcAzmsBiVAwzHLkSem3cg+I9z4OQ+TR7hdSgieUv0Xkng0Bw9i9h/N6oBggIvVYYX5zxdvMhQT3Cxyu7eZuEVTj8ek/PTg6wNRfO3Y6P+E9Dfe+sXYGfGx6v/u+r9Ge8qxHHiHcCcMeO0TiiOTlB0d9jnUjv2WO855UT5paZLwpqj6D", - "created_at": 1791465430, - "id": "a84e34840a8b95f0936d76253c6f29dd41d9d12638244518f951fdaf5f3df92d", + "content": "AhQManTTR10tHWxIfc0ily939O0FYrHBpChM/WvFu9Wd8oqIfsX1cN2B3GO+eTT99biFxiqlpUBq8UgaCUX29wnM4bKXFjjS4R+Sh9WCvt0yY4G1VUS8eFBoMfFOpTua5TrYL5pdWkfxsDI1eF8BaVT9HHffutfps3+Ou0Sv7P+Ea/N1Tf0Crt+aGGsCeYMBrBN3wLm1MMXeeXL9NlwPHfOi0M4LFYSwFGt5tIuiStRMRAjxTGypSbXQxg3VSuBMlGXA", + "created_at": 1791467351, + "id": "5dfee9f73da1d780ffb9ebb6b28927d345bc6a1889e6624beba23a9e6ea5baa3", "kind": 24242, "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", - "sig": "89a56487283b0b00e364cb976a140edc0c9ad274d79455b2dddb44b1c27c24f6b182c9298f5bc7c6289707faf33bfd478b485cb33e2d421ea5d95ce7a5c97872", + "sig": "6a4896d3ee07473f2e2b755a2cfa2e69698c4a6d47cd9160cee39965215c3ed2f112bb08e13dc7a570c71947b62c3b851c799a11ef32d6cebf9697504355072b", "tags": [ [ "p", - "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" ], [ "t", @@ -1110,7 +1110,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"b26e61103edebee548eed5db73cfa8b64741c178f77b0fbdca65b71d5abacc8e\",\"timestamp\":1791465433}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"f5fa06b53159118ad2c6cdc607faa6c0ffeb61aadc38c2ff47c4f9e699d222e1\",\"timestamp\":1791467351}" } ], "index": 1, @@ -1118,109 +1118,109 @@ { "length": 1, "nonce": "35de5f95c9292fc722aade90df4b0fecdd4fbf49fe9fdadd24876a3eda5d44ee", - "payload": "AjXeX5XJKS/HIqrekN9LD+zdT79J/p/a3SSHaj7aXUTu6aFxLmJaD0EsHyLoXdf6RhJNN6bv63dpk121SaleIOj0AdyfTQXrJnv8KoPUoS4zb6GygOryATgSQkNljvJRAa51" + "payload": "AjXeX5XJKS/HIqrekN9LD+zdT79J/p/a3SSHaj7aXUTuz9p1RcC5wsm9hF5Rf090IjPCw/8ywo0UQz9pgmMxX2AG6gGCG/fPBS+akdomZTvY9Az7TrA1iSxsl12449dJUvOF" }, { "length": 16, "nonce": "e93d958af5dd6cdfe73370382267f2d811f7f63fcc8e81d7fae888daa0e3dcbf", - "payload": "Auk9lYr13Wzf5zNwOCJn8tgR9/Y/zI6B1/roiNqg49y/od3vHK2FpvWjwC8VobBGQbxVVafADixICMvpIwted99FA0N+I3hzqcrTVhIvmVFEqkZxoD8ZPV2AMW5i06nW9ALJ" + "payload": "Auk9lYr13Wzf5zNwOCJn8tgR9/Y/zI6B1/roiNqg49y/e2GpnKM0XIWAkPaeTfi2JIkFBc5P13+RzyXk9qcEzwlLX1a9ksN5g2wGlEdDrBsgGKyJZa2B9jKAZzUg4Skflgw7" }, { "length": 31, "nonce": "53ffa6c0cd2fbb0948dd600605cfa2217089270a72d46c1affe2b99420533aa0", - "payload": "AlP/psDNL7sJSN1gBgXPoiFwiScKctRsGv/iuZQgUzqgukioFUiEm5ZfTrDhizizDGKFJRO91sF5631JrXJP/sztS1aeP4kGWGs8PFxlxQXJ+OItVcPxZjeGulqSCmJoQOIj" + "payload": "AlP/psDNL7sJSN1gBgXPoiFwiScKctRsGv/iuZQgUzqggQoatyMD6KgksddMJaA7FBmJDhxIYtwVYa3JHwp2JctizzgHh9J4RPoqlc0v4JFx30TCm0iMiZyKMKcZAI7lQShB" }, { "length": 32, "nonce": "dc6c91f26e9727c63d456dc955671f8a3ff8c737def22bc80b98218f13abeae3", - "payload": "AtxskfJulyfGPUVtyVVnH4o/+Mc33vIryAuYIY8Tq+rjTQd5yHtSore071JO7LhTpbF8JXXpKgaK0ugI3VD13F8CjC6FE2fjc/baIWmBWv3Q5pQ7Kytlun9CK+LG93f+78Jt" + "payload": "AtxskfJulyfGPUVtyVVnH4o/+Mc33vIryAuYIY8Tq+rjVoOp4ZoUxttg9nFx6OaayM0gXCYrLQaSGcJiJN8RtDa8+qe0a7rzFHXTGNMkLpISSaPvXSb5P8pzLAjCXlUHe2Am" }, { "length": 33, "nonce": "2f53060be3a6091fb8ea2c200f2726eb042d46c9322fb4c588c43cd7ad35bf3c", - "payload": "Ai9TBgvjpgkfuOosIA8nJusELUbJMi+0xYjEPNetNb88SbmzvU0TdkhnI3YVBVOlJk3K8rDfXQ0qWfUM2yH1/kKcQDjnPjULRXsA514tr4KkYcFv/MBxD9Mikeb9gaalFgwQpZPXbO6qYcJ7/DN5+bZocR/ZaeU2KeIVcH2ekLwr7Ik=" + "payload": "Ai9TBgvjpgkfuOosIA8nJusELUbJMi+0xYjEPNetNb88sIiGzPTZmh1MW+b1TaoJvKdmTgAwJ04P1zh5HurmH7CM5lV9m4JTVBB2DPQV9RtZR++3C7OpXr6jxA8iY1PCn0bm855OmhtjkCRP0F/TSKQonXoq2mT4ATD9TuPFw4Z+ef0=" }, { "length": 64, "nonce": "56652b68bc15a9ec751dfcd5b9534ff2982b173472c1e851f925074738c0dd9d", - "payload": "AlZlK2i8FansdR381blTT/KYKxc0csHoUfklB0c4wN2dYzU+Djtvhrn1j2rFsPO+OMQ7UHtaByE15ToTG53aSixqEXZt9bEEJ/PL9HHWIZd4iolCR/xdy1jKNdxxHGeJtEuXxzNMIQ1TaTu8vf6BzWPkmqa+T24n98FtLilkJDt5GC4=" + "payload": "AlZlK2i8FansdR381blTT/KYKxc0csHoUfklB0c4wN2dfGTkupKzBFHVb55w+IdRCuMdmPmeKeZ6TxtcizvP7CpgNdRn0nFObeihoNCMr6A3vQwaOhgOyXm/UmXWHgCvU+XGQkX+N6lNgp/O1bA3B5YG2HRIDxlehdBVUL/iqkXGJdA=" }, { "length": 65, "nonce": "e19794dbbf768d6838ddab2711eb037a72656fc34a4869f63e605f2451c2f09a", - "payload": "AuGXlNu/do1oON2rJxHrA3pyZW/DSkhp9j5gXyRRwvCan9OJ3z+eh6a514hkckYfWKZkPpaGb9YaLfbTXJUFpryvmX0WZes3Gz6Gx3b/VH00s6eNUrwUhUO1ObNhK/InK15H1339RX6+Jy5CMfcjrGLAnmrIZujxaoP+mHQZ9pN5v6BMybpU1sVeY3FVFzR9feZueHAlW4Zx2yOaC98VmL/odw==" + "payload": "AuGXlNu/do1oON2rJxHrA3pyZW/DSkhp9j5gXyRRwvCan0dXrrTiqhXuQacUdu2TLcE6p80KNeHuwAbJhZMHwhq41EZ4e8uG2uA4b83tTYsFzbiXtj3k+NzSxl/Mxo0+r6+Q+mxggMVfbOaNr8GxYzfGlXKh4fAtvg6F9A7IF3MkAK+L3E+31euhsQU0JwcGp71WM5VXsLjQGGan5EFPTsKlIA==" }, { "length": 255, "nonce": "a7c97adde5a52126d39edb1dd425756d8d49a6de7c1afb36731a18ccf426ee1d", - "payload": "AqfJet3lpSEm057bHdQldW2NSabefBr7NnMaGMz0Ju4dGMoTN8vp1tQiwKUjEtKVOY+FKknzNyVB8M8yakkfN9rSoyc7K0H8FnVYSnDdceqZG8XgC1DGblnTrS4j29VFcU3WOkcqkvR8IG+cCmACRpm/eE33G6zgdEqxNAVGVRsqpcBTKEdnl4ip2PEdBUOmbDbkmiyr8NMvHhZo+mHbdWT0C8xTvrrJBb5n2srn3bDat+8ekbS5gY+3EmwBIPPJeno5KLXJg/Dt4/wWI/s0JzSv/YjpCsAK+kVGejcq0Fny4SnOlCFJ9jOzKqmtVHtai75rUexkKDiexozGTStwfKMigQ3BmlcDXf9W+4xtjl2ytLh4GY/WBWmOpxbpYjAIexkRK65KOB81z4QQZwtnABLjRm/Xs+rgdPRrmLZRdYh/FMo=" + "payload": "AqfJet3lpSEm057bHdQldW2NSabefBr7NnMaGMz0Ju4dDtkUz2QGWHYn51pKZR+9OgEjpnjyAPlGxvgyRzY5Jytd/LcTPmchARlep3TeUSm14CgVMIhcPUyZCX+03rKI6nTo6toG+0hseIsbsTkydRAuH17l8HXxHOZAk/FWRoqJPoltu1jdKRlaCLGCo1RVMa9eyTEsYku8q+5vJSU5obtNNCOo4YPCtuhw105fVnyW5x1a5SGniLjJ3K/miL44SNYu3dedDUOgDnvekwRZoV+xhfKNU0AppyuMV2uI62XfzZaybti5bgV0EDDfqz8Wd2YLPnmeKIe3vgoMEfsygRjhv/Kzkz/qGrXYqwsCjjHbFBYka/uhxnZaodjw/0dLZKF3KEpwnyzyc9A97RDl/9gAoXXwoMfKaQVIhVnscErv8zM=" }, { "length": 256, "nonce": "9dedded080b305808a08622ae5d038a764bafa0b95047827047db26141184b7e", - "payload": "Ap3t3tCAswWAighiKuXQOKdkuvoLlQR4JwR9smFBGEt+JBHKRxXt5N9XresmCng1trYmDyv968xRuzBtHRYgjypiH6oj9nMUsWq2NjkkvrWSex+KSN+wv5CGwLrldBKhXWNYXxd6lICjAZWz9tDYQMmE/f7d/9YRxPHyENEU1DtxTfueTGKUKsEUxENa7yjrEXqgp0sZYYB9Qr7zJVsmUJO96ecppS0Qt1g94haSS2VUhUora04QKqe8k+fyM+8O9lehFxNUJNYEiHWlcen6MoglXbYqaZ6cQ7L7rzSjs/rEqfb0ccCHnHbKwz7niMhTAJJt0tdxOSjLOgQnmgXpKtidX0ADpUdhTdcCvIAMwwJJRXeaLLucEWC4G5guYvDSfuQ9r7aRmYKNtynr9Eg3+ooO7BiVKG8dIp08J7po6dhVeDE=" + "payload": "Ap3t3tCAswWAighiKuXQOKdkuvoLlQR4JwR9smFBGEt+q/iovvILiF+mMRG4zLWNjfslOUkf2cEsLyEtYFz0BRg43AgJEoKLz75KQkRO0WQwkXrfE+4hhagl3SaIfzvZfAImw2+fN2AlzuOCvBDQBKTGwzndmoTpOr7rml3TQJx2JspFlGUWM6ca1FQA4jiziu1SwVq53plOow4Wu3Dg85LNIJmf1+dRFY5gr8pzpvViCnc7Cs9finjZFtCdWBU5eIfwNhZmY8R7O+sWKHlQ9clhQwy7W3PQc+sqthdhGIjrVUGHftiWotd6WMhkI6XG/yGkFppDOniWnhRLjXdo5Yzdbnkf1+qOZKBilgTCEOrzEaonUFUWkGShW4pmvjxWb9fQeiri/LL3dxoE8ZfJBp4Sx2VUMYLupNU6XR5F/5AvdOY=" }, { "length": 257, "nonce": "9ef8f1a39d116fd891bff7abd67cfa4f82be42d3ac626d9375fba2c8fefd96d3", - "payload": "Ap748aOdEW/Ykb/3q9Z8+k+CvkLTrGJtk3X7osj+/ZbTt5nLG+NE5CyEF3SFbvdiOlwHbnzjAbPy9dmdvem250azZq4BNGTbLcbXKYoux2doPEkzKqWrtfhXbrtn9XIzMRn3kcOTKqt1I4/Le+SOfw2lzdYmeE0IZ6DQNhzsS8c6dXZp+XNfwJmPAZbZc9cKXMwqPaINz8aVQ43CUkIdS7x6ATHHEck7K2+MnpD0M75oMBVNG2DbRTd8K+9GAMJNTpCUg5VigmwZZZoRaGi858JnTzrHq8t2ZfZvNBajMKk7yGseysVqEmlkVivwkUX+MPLPoxZRVZv0z3iCFj4IGmA2Y5H1U+rHuz+FW9E442LGSJvBZY8nAjKG4U3AFzYa+Nk83dmpFeYnpsdO9eqVuRv1JMzZj0yoUiFZO0j1v/FfTBU4vBRyqCra01S4gt/7MDymxFO4bSi6RDYi1B2ARkg52y+U7oS5DSaDxLKtLfXfpcGD6ZQIyaHfVNY4zxNeUsQv" + "payload": "Ap748aOdEW/Ykb/3q9Z8+k+CvkLTrGJtk3X7osj+/ZbT/xV0VBPMgrVxYDv4NkBZz3Fd9aqEcZyRj7rLfdjAHQWT3yxCLTSdpek/fCIu5wmkZCjO1ivI+2q3UXF5Jeb86hNF53Eg844fbkNymv0RKaMjTgL/0pA/zEELcdoC9Lb+myTce9k/Kh27a6G9ZaT4/pphM+M7kvPm2LDSejHBkRoccIGQP5Sh/+ZheFoPF/Y6TwhHf2b2y6mctwM7DSARokt4UMzS3iWtT92hYRuFCUdlrpReSWmxSXuq6ze4qp1lrrV9+dmgW2CoZc9YhaICz1Lga9a6Zg8dSi5gpzPgnvjnEB3VWx/JFBbuqpyCU5zhDHTkecBq+zH7zw1YUXQxoFXtL1TGtIEU+9u/LjA50jvzmxfmU2TCnhkteeNsAVok2zt08ENb1EujRLiFqDTTwE1ymtDCgDyh8r4uLsiJBakcCqXKivveBTapNnZs/U/8vExGSHD1w8nbhaSH2uCxTxAQ" }, { "length": 300, "nonce": "6eab9ce69de78202e8cc7f37da0e840309039f1101323b9703c88abe46599bfd", - "payload": "Am6rnOad54IC6Mx/N9oOhAMJA58RATI7lwPIir5GWZv9lF4wSQtMZLDKQJs2lWZnK70P4BygReluiV4DMLqZV3Z71YsJBMogGDUHpb6HpYDxyYFiyhkSnMSMJzKLQtOzYmWsF/zeE+XIbo0UdcA8owkzSWbtE5k/qT88ZHlooZIJQQ/cw8HM3dK7+FB9uk8QGQCFd2+GlZqf+q8WvBGZ3KCGY8IvdKPZb6v6/xazFSe2FtbcfBKIx1XkR+Xd8NUhphYRctXBF5WZRuj8R+PNdHvRikERZTcDVtaaV4wVg9HTlXO/PJt92NPlpkzw43VnRmvIWalkN358NMWXM6MTAyB3k+q5V9HzuRRAoVI8EEk/sKhvYew4+58DW5bzhNJtp2Xz5sfwR/kA3AaWMqqN6JtMQfEuyvKblNj717TeHPRuQ4yuZ+wr1Kf8U3TYFxmlbzlIaIIlrVgPOrDvRGxxFTQtkTQZ+B0b9EdNqSHhKxj6OB7bJGm4YdI4ln2S+dawyAHg" + "payload": "Am6rnOad54IC6Mx/N9oOhAMJA58RATI7lwPIir5GWZv9PqUKf9K0lJLZLljNWJqNnHBFJdVgS0Gv7PSZ5mQ2LYhyOpzSDyrTf9PMyXIp+SyRqRJGvsExtNlbkKBOTLPxGwJG12YxgDg6Q+cDRwfM70eJXGKc1t0m5HcgXvIi2K9m4LascSy7YdLZ+Lt7NLQ5JO/WzG8kY0k3pY7Pwe40d1A4nl36bMUVO1kxlHeQmhKob6DHTdERz1fhuDYmbmzOkoXljTxMxuWiIlBlGCihqcSyOeXian59nFG5ax8tSV8XGCHoCF1xga3miFKaIntE9F+j+doVKZPBpBUZfVlj1SKnEAu/0DP3WVH9W56NDtG9cnHYpj7sLC2W2eZ+Ag3bb4Uc9tQtMj4z8bbQvANn/uSA7l7hpsLgB08kzoZec2oMjy2KuMy7/X3hoC4C0PrEAPN1R2qZjdXKr7uSSMDkI4xNqYrhVchCexyCoRs9TngmG5/0M9iksdTrGd1JKweMQjKq" }, { "length": 1000, "nonce": "d79c54d46de6666f32660ed419ad942879f75ead7edcffe0912a7f0a1f199067", - "payload": "AtecVNRt5mZvMmYO1BmtlCh5916tftz/4JEqfwofGZBn+Rzo88AvNSzzDX44IUcqt8t04uIVL+yjqE1OJoToRvL+LKgndc5Aaa6QVTnjqvhpV2DUssryhrzdvF20LkmWy8rFADcemQyr6RTmqFiPbm2Ge5FkFaPx/HAGb4TpjdaZlq/qdJvQtL1AzEvhMpwCfOkDLg6oy7Ws6unuGwMeIIJNcIWQqSA/OohO0BYgqq8ZnIWUwEooLwDEFX4b9TC+mwteou0kKH1MT/FLjAfL8RyVL5DawbGr6Fq1xkt/+fTrjiOrJebdbvieuJDj1Awh+r7TA5+kHqA3epQg7ITjDGTRFi9PiPxdOnf6wBChot/DioJBZoVMEIQxlbWGhTE4+DY/lcOFq/xxk/gnEjekxAzSf8V2UV99MF8KrC1E8fgqRpBWxWy6t7WsSSSNdlpOMcp2AvQWpsu7t9/ki0dXjnad+kYXsQfAp8dlRAJHBRzqJN+3iSC1U98sQRdhECwQgx1A9vMcCwmZC1oKxZqDU7CN10xe5XvSMrWS0SatiihUUSzq25f3vWPyh++11BB+HxZ+I6+XcZXz85lJV4fx0rp0Q02JSmsKFpT2/3521ycybqKLwHAzdIQyBQ57HdaZIdp/Cv4nh7JIx471Al2ftEpqwAjjA3VgudWXDs0aq8Ia1HM24dR8KUL9tLyvaMN1H2gw16PkZ+ht6IZyNMgSeu+EpOS13hDvn9BaI0nD2DnUh265vt3uPqu6j7s1xs6wV8V9/4BlpahwNljr2v/ZP82dT5a5tfWxjqBKo4bZpWrwC5fH95G4iTJCmMQ3dU1h4GyR7SYhDQ0kYWZb8FhI8DGWPvUdXIkizLhxe6X0iQcRKx07Zc56WfgVMl6FGoJEQm6wc90U8uKzX0TDw2q/myQ3T6+SRm2oeQWQiJDuSheI2BSF04noeqbUrgVaaCM0AVnSrb2s9JsjYiDbwqj/H8/IMs3BW25BAHF4JsDLFW5O5vJOl77n+kiFlFfwSVyCE+GOGe66WZH9mSn8X6d63Y46I5n85QkJZec71w+ELtzoGSXKrgFLENf23d0PhMpEyt1lCXu/mjFa4e0bUzjGSOw0e4GHxipSHB0HQJqfOUCVnNjk/W9Z75NAwd/2kV79eYZcTEuLzI83D8R0UgIuXG8W+9V/SBkUu9ixqL6oYF578rlJPYLa+plOD+TOWYF95fa02vcu1PY9Br1fOP89UP5MVUMPW/QI9S7uvAlYX0Jx3RzE0pUdQJkbpjaXse7dGt5pfsmMYJnd0qpShtrZYJHTo0kIoLHrXXLiXX66mYOTOmI2OLfnm2f58Ds5WcaaQDIEMewPZdnXw9uofycbdwWd0tJhQkF/cOfv5wMJ6rrMe+5bNrGQIbh2awIJpJs7sVckUs57AoCBz/uU4cWGF4zQyb6Hdbsz8jDdCrKJTyuYRYg=" + "payload": "AtecVNRt5mZvMmYO1BmtlCh5916tftz/4JEqfwofGZBnZa6BSsyAE4+NOokhZ+dL7nDfbQ4vzDHry0VrMy9vaqAUvGOHDpfhPFEyQhM9iEzwbWF7QyFcTUGYhGpc09xleeo7sHtMisVcfmY3Ckr+vhcbDFbwCf78XAfFRwVJuwlxLURuSva6X5y0zNNUTLMu5o0JGQCC3uAZSs87HiDE3m3vZHpOo255xJ+70o/MoZs2wgzEysFIvPnDeAG+5kI0I9Olm120LtmsrfnQ/oIZzxnfDVHKGUFuZJTqVtFxY74eUeGgXs+6z92AOb/dJ2chp/U4vKzoRHPADHKcpJLi5l4seuvX9brtwIQPh00f8+5Ms3mNg9/czKWgkBQ2d5dX+UKKK5mujz0Ll0ryJy6ybZFkkIAS9pAANix6oqxB/0GUWB3cue6YdZXLv6CTUYswKtza9UPsh8Sn6qfgythMSDcg1EN6PYgoQcW7JcYj/h3d1/e8NPwkKTQ6nPBjeBB9EAH1Nb/My6Dsq4y7ID4TFIjcatYK83VSjWeJmrIXNnDbU5fBlmuBgC5VHxUTNHOkZRW2tRouEG/S0+0adhj6gW+y7dQMTwNxxjxiLHVifHrX0hPzyQIFBqe5aLkPF0j9KAfy0nVE2aSWca0QLZn05Ar87orWuEy6loo0cRJdJTL9DxHXNz2jQ29kUkw92UtItkeXQIX/RWIkeweo2dmg5DjDltUZZyycbQnEbSGOmt4AlN9Z+3vHd+j+4RMW+X8xYIC2qEZocS7g3P8GazzUWQmr9A9hzLG5ot6aTzFQPM7EUf5IGhJMqt0uTuDAVg/S/tWA8OddZHNbAJN7bD83PSbxkJswMvFiioNugdpdeWj6oNHYY4k0xIYJ351nuZFjI13PRsykMRLzKEnLi/osHxDTBwISSnGeTLZ+cc94ExR/4r6b0AQMIV23evMU0QoD9y8YQdsGVI+Df39TzMt8eR4u9f1MyayaJIz0ZLBRNF/QfXhDa/odJlbLK4dLHymg3118raq5Ccq3cUoSMwh6czA3/dRWKWED7DmRfcfoPx/TDKqy/+LsQtgeEgoUAkjha1zDXLT53SxMcB9Ai+2VPWBZv2bf+BUlCeB7boYQT1WRH3xVG70qQqJQH96vlYD+jDCLe3ziVXbnfeFx0NoGwWtAlaWgI2Ew1nXtf7wqcYxy/KYbCaKDE5kwTRC8eBmlXx4J4tIRBli57alVUXUeGWDXylLaYpK7XSAttDyMUMi3kY186MPau/juYPBujTRJWUYH4Xegx4C+zoUnVKOIaIXA/eh4oxPOZPv05ngTxwsslrbNkMVx+FBNEmUCUYzZfGXiESHKw0V1wnBjH/1ohileaABF5J+mlSOHsw2rW85inu0cZ4Jp7yjCuOalvifWiE4KKjP4D2Gb1iGtgZVEbeMv86g3F6szWvT/64FzNt7HFY4=" }, { "length": 4096, "nonce": "b048e3362e0981b9767a99c6c485e65329c5d1248f3d112104303fa648f6db0c", - "payload_sha256": "ed2bf52c8ada5d1cc30cc7e40b9f830e8c869fe7d98a6fd0ac911350b1177f7c" + "payload_sha256": "b455b2200631a277d49e199650d1e951b662df3990f15832175a06997a6304f7" }, { "length": 16385, "nonce": "46b2f6a60d194d6a689d8d0fe9b7c72c79a48c118f90e5ad14974d9e107868a4", - "payload_sha256": "bd4bfda45dadc33cd1ba04cc985953b60e4383f8872fa65a871a2fab24efcd99" + "payload_sha256": "db9f15d6bbf9d70fae598024e014f483a864e3d86b8901b19512e6247690fabc" }, { "length": 65408, "nonce": "c3d733c51bd5c2ffe2b8134ac24cbebda301d40315d3d3c09860b048905bf333", - "payload_sha256": "438d062cb3642c1e93f5af6f91c2ca77720a0f3d16737cf55966fe626ebe9672" + "payload_sha256": "c519651fed8c788bd95fcf4ab2bc9204f9bec06f41d552e10f439fabb1bf8f92" } ], "peer_pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", "peer_secret": "968b7a8f13cd22fe46e2694bd9324845bfe604d7c259011b130ba45cd2c3d70d", "proofs": [ { - "proof": "b1a4427751725f0cb43f58f73ddf8a1e00672c557961b87ec688f0c8056e3cdee6af61936f0c0cefc5d4acb7aa0b66e01754e87d0563371a65c4e766e471d6af", + "proof": "87d9b55a7d562e5009f2293e02c3ca28ded370b0ae7335b1811f98480b600839753b0a4d324c7658953d57431ba9355bc833ce5d34bc444b10d6435bb3ef7e7b", "timestamp": 0 }, { - "proof": "fd7628c25c32d0e7fa0052ae242183c82b2b2377116ad633ecb558744953207fdddeaf18714713d3143a404a61cdcbd47f4df22271b3e6ec24dbcbba3fbac6af", + "proof": "d65c0ce0c0785d4db4c05387be005da7d8ed78a375e400267f755ca0c906563dd0500df802a1f59898bb94faaef1cf5bf4e6fa546530c508d05d24e321fe7169", "timestamp": 1700000000 }, { - "proof": "b7145433d4e427494fe0557dca4bda0076ef1231e0ae37bd10558d0ccd47154ed66a3ccd9049582feeee681d390f9b38620533efe5c281af86a53dd4b3601a82", + "proof": "031e6d995070c7ede12581f2a12bc8ba059d35ed33446308698047d37f3190be555b73949b4e62f0e82e6e9515a1481687a32e07f37b50ace7fcd09d0a74da78", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "c15c6bfde3a29ff4a1c89e545f6077dcc2cc650680e7e0b93ddfe4fbca2fd28c" + "transport_pubkey": "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":2,\"verifying_share\":\"03b455ad8e309d5a4f49ef7ef9c03ef04d268c589d6d8d3910f5642618852cd04b\",\"proof_signature\":\"f257316a7736945a80eefd7f62baa44abad71937b35a5d534b9105cefe71187c132dfe2eed7e65f1c6613b8bc890da493a20907ac70db9ee661bb6bfbb7caae5\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", - "created_at": 1791465430, - "id": "bba8d4cf4c94ffd8502c1b6bdaa6ea4c67629be4ce893b5b13b2833fc16d1f30", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6\",\"share_index\":2,\"verifying_share\":\"02ac88e83996019081807cfed4dfb726dd24b53eacdf27ee911cc134143cea29f7\",\"proof_signature\":\"2c1dfb8f3496c0ef74719686e0d8cdc1d3a66c5631883ed4ac331ba18a4c6f940865e0f1d42781504628e4f6120253dd810ed6f715361f47b7b11ca1ed3b83cf\",\"timestamp\":1791467351,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791467351, + "id": "6335ab42d3bd474f9f3c4d494ff2604b7be42ccd8d36e34e23b61d142dd10ec4", "kind": 24242, - "pubkey": "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d", - "sig": "6308bed8b075f61f07a478a90e0d898f3b2c32e78575076926ff7b37ea2e0cf178f65310ca41687f34552ee3193066c239b8f13c5d481dabfd93c66c29041df0", + "pubkey": "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2", + "sig": "06156de7fcf4e6c1b72bd0d9fe1d20fa36892cffd66fbc92f2a51d3db2d4d778130971b47b871a0423c3b4321a908090724a73d2ab7764baeca77fac5f3ee106", "tags": [ [ "g", - "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" ], [ "t", @@ -1228,35 +1228,35 @@ ], [ "p", - "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" ], [ "p", - "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" ], [ "p", - "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" ], [ "p", - "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" ] ] }, "events": [ { "event": { - "content": "Apfz+rLZ9S6B9vgewRvhLc+QDGlmpywC0YnLq4R4hgqdm7K+0emyWti3j+SeKmiEmSPtLBIA0kboG2JymRJmkfTCJ4U4G3jU8OGD5D/PXyJtSwpHYP5zA6T5l0yP0Idt24R/mxv8i+BkTKcydRIZ81xaNSTpQEfA95spmf+ovmAxjRCjFbGgz8NyezfsTq66A+SN21RDVWSBhKuAeIGralQwBUKb8GKn48wGQpnxyt8WVY7Y/tcQCncIeNbcghnpKn7z", - "created_at": 1791465433, - "id": "51a5d08afb67b6ca7925b1d0d5dda964b3c24659bfeebee9edbc45f35d7da5ce", + "content": "AiiTQCXqJUJJ6GV/00qaWzpRa+IiIqVOymzOE6dxFIXs69KpI7OBpIYvkO+aoNXLASSysVYdqzTozFKaWzH4KvU5xy8aIFoyFOm1NKJFed83Qm86vd6TX2RMf5eFpdmmIxEBm2TaiIEOsPSdlQKaJOzbXuQ+N61YOScKnWK/x6t2JwQDMsUwGhkIuNWcOjYpBduS3NuEwCJH0YOpARJvNSAk1gSLmwdpcAk+yNAZDjw50nFjm2hAz9jEhKpLxOI/Jlo6", + "created_at": 1791467351, + "id": "b0a1a98262e35b32e0b277fefc5b8816fd5acdd1f88a8dab5bb981dfecde86a6", "kind": 24242, "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", - "sig": "97ca451dcd484776604eb1e68f4ef73ab7bfc112e5b29357af46dcf327e9916a84e33e8214b7b97734ec5e6e2bc4e1747b5b2a8def8a62c010955dbb5c0f59a0", + "sig": "1685e8479e4fc326ea373bba819fa2a92c23b74f74e6b30ccc420166b7b301025fdbc6ecf49b407347eae405deb76fc4d09102319bc7577757ead2aef96363f2", "tags": [ [ "p", - "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" ], [ "t", @@ -1264,20 +1264,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467351}" }, { "event": { - "content": "AtXmJaKJbSf4QDlwMBXJtMqhrTtiJyZyG3inPy5QaO9M8/hppQmM7JcS7gO6n0vmxAVf/OisYotzKEc9DYJWWwsm4pGArpH4yQL0YIqoHBC3chHdhtT2SskwiEyFZSGUFqp3cN5KZK2I603M0ULF70JCzVp0Thd2f56Ajkr+9DXJnfB9nNdaGmq08VP4cdMQZSLZS/646sHFKFXG7zA8pdRgd7/1k3FBcE54hGD02a5Ej96Crvz9TzfNEgyTjzFGO72A", - "created_at": 1791465432, - "id": "52e2a5a58f12ffeb19d437bac5ab77caa9e5ce1b10f89a8c9c3ddcd3cb49dfee", + "content": "Ao1xvEggvKUDodyy5NusrvCZ+lPu30kxawJXWKcnHHNEXDi0Vf03RwpdOLxMPXT0C5KJtUM7o5NFc6N++OX6TV2l+Gg2gGNuUJhDvJcUXh+HVFiHblAQzPFnnWT175V6sZbrvtFQoBuCibj8SSqJluheoyOg57CMLlZnM8dhVONU5DKdO/NB7VVe/rKWdlQQNNfiMec+IkkGd5vNDIpqV87rgRxHIjXMYmn7lYqz5Sx3LSRnTzYCeAO0TH9cA7y1ENVj", + "created_at": 1791467348, + "id": "5db3a1a35bc10e155b41c936ffd616e879da27676ae6537363e5794e519235ae", "kind": 24242, "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", - "sig": "6fd5a9fc0ed3828ae7ee164c1900ce9c5455c028db9f04fc4a8b24cf8106759a8bc966205d60657e6e0c7d89cbc7cccd88fe6b98db2b860134983716fbc9e8da", + "sig": "d3aec257bc3499df635c6ce19fdd786fe82cc56fe0f2cf9550dabf484cb78b8b3a54f81d11d1ba5ec752d8c1c99963401f4ed60d47469480ab6487821d0ce096", "tags": [ [ "p", - "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" ], [ "t", @@ -1285,7 +1285,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"a6dd1d632f6566be06854b2c112505bb873b78ba7ac5f0d08afbb384ae9b9054\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"b40befa0863149d4c89e53c7b01487708fe6fb3f765f7080f63f90105cd18ade\",\"timestamp\":1791467351}" } ], "index": 2, @@ -1293,109 +1293,109 @@ { "length": 1, "nonce": "c7cc4ebc48fcf9ea4b95013bda8d13261f64aaca9cbd1a04d35b7b08bf9cf24a", - "payload": "AsfMTrxI/PnqS5UBO9qNEyYfZKrKnL0aBNNbewi/nPJKlfTUNuSusOsKhJ35Ifw5vITdGXPZtQcDg9jcEakxieReFsPd6oXW9jVLV2uVvwnzZQmO9T1u3uIsgjqYcIHrCmn5" + "payload": "AsfMTrxI/PnqS5UBO9qNEyYfZKrKnL0aBNNbewi/nPJKDAcG8cUBcwcfMPjkCpOuuxXomxtLH4KdnkIgLzhhjY3wbo0v5hhu3lTviuMf9N1bULZWMbM/qEaEQp4dOjFi+UP1" }, { "length": 16, "nonce": "21fe3bc66a60a3ef2f02ada9c91b6b742f816b5a62fe2826643f49a2ccd13d93", - "payload": "AiH+O8ZqYKPvLwKtqckba3QvgWtaYv4oJmQ/SaLM0T2TUutqLz7tykrO/0oaOUoWTmscIO770J31SSGdI0De1B2qEzp9fraL8z9u4vMmD1aKlLjGhuOByyRqp1vcilrLdkqz" + "payload": "AiH+O8ZqYKPvLwKtqckba3QvgWtaYv4oJmQ/SaLM0T2TdBs2Z4uzw37AY4pnZe8AgC1cVRY/jvAA+QYOaSpjchBfbcUnVS/EtEczRLRMT/KYaDuEqvj8Ai8n5AxbivcYClc+" }, { "length": 31, "nonce": "ad8d4a308012ce84b463f1c0fd2896a5346f777d94db69fdf7b4833bb1364dbe", - "payload": "Aq2NSjCAEs6EtGPxwP0olqU0b3d9lNtp/fe0gzuxNk2+FJRbE2OIE6zmW0GrNSZisyaTWil7g3OU/9OR6EhEgFyy2G5jTdUMOn2yQgMolkncVNezBlqd6n1+lAQo9Fzg6Eo2" + "payload": "Aq2NSjCAEs6EtGPxwP0olqU0b3d9lNtp/fe0gzuxNk2+48UtpyIiB/lEM9Ul8nvRMe+60tDdM/qn6286fNSDOMzRwGv8yVZpDnXPlyHPbHaPBIT7NFPckkLqchqHaxUPcDvJ" }, { "length": 32, "nonce": "f23e86846416e77c79c013877140d442af1c415f97ba08eb31905803f86eb903", - "payload": "AvI+hoRkFud8ecATh3FA1EKvHEFfl7oI6zGQWAP4brkDrhq3GyBYg7oQCR+sXEp+suHHV5qApbdtE80PvRRmijlBfaiC66h77b61ATdzJoi5Re5Nu8w74KR17jmwtVX1syS1" + "payload": "AvI+hoRkFud8ecATh3FA1EKvHEFfl7oI6zGQWAP4brkDvu+rr1+kcZlwwxwXFR0/OWPHhbdRiojptyCFZgex5G88EKKIuMXVPPdja71kOdPB79tIhqvL+lyKsq7vbelvrrLN" }, { "length": 33, "nonce": "d5353cfe6c1f62a506e97593886195a2d6d9e1dba2c54014d06f48d732448143", - "payload": "AtU1PP5sH2KlBul1k4hhlaLW2eHbosVAFNBvSNcyRIFD5z79Go0dLuFSHmN2QI+uw5PaWNd1gi+nGvioC/ZJWhAMtTpskNhxWNfhSZ2uHwDg08u/PncL0JbByKDbPugrrZz1yLNreJ5F1cfNnACXuvYYKWvum2mUk/UT9QyyHY8M7uE=" + "payload": "AtU1PP5sH2KlBul1k4hhlaLW2eHbosVAFNBvSNcyRIFDuxZOA/ygkkNeTestPvK/Zh6lWS2GjFtjKlA2aSKpUj4niAhSipmCZE8//ZPR7f0dcf3QzbjqZdQZsBUbmIT3sB3AdPqprscgmmRE1j7ZgykW03080pI1bWwgqkepZFl6Qy0=" }, { "length": 64, "nonce": "12abfa87f5565130cfc5bfcab930bf2116de8cbc95e5d1fa03f71c396f0cd19f", - "payload": "AhKr+of1VlEwz8W/yrkwvyEW3oy8leXR+gP3HDlvDNGfNTfpMdlJB9oeiXTbPHsWGq23wsYaDarszgLX1Fm8aMrvep7lzSIL5S5DOg+iOVtM9p/npnbKaSirMXu1zxf2HyoxqaOM9q3ARuDwBLcfxseQ8RFcF+ZC5J0b0DU6e7Vnhqo=" + "payload": "AhKr+of1VlEwz8W/yrkwvyEW3oy8leXR+gP3HDlvDNGf+tJU8l4f+xhUUDoXC6Dul/Z9D7VCU512rXP7fz4rXBT2sZSEzIFUEcCWq8qzbXKrVVmF2AfJ8lpqxlmnq7yfGQv4hYMeMa5l3SzM2gQfNgcDf5Bw46pDvr3gkHf1ya6cZHk=" }, { "length": 65, "nonce": "1e1459b28fcfd4d6baa69fd2641112cd2098058c42adb209ba85633b85618e6d", - "payload": "Ah4UWbKPz9TWuqaf0mQREs0gmAWMQq2yCbqFYzuFYY5tD8VLCSkrtxoRnw2hsBBh9gKmrF+HXQApA5Or/a55st40nQ6SATrm81iURz/XCadRlA+7EGquRcHSIP2D8U2Mlb47rVm/r3SIdym42k1WWfolAv7LonlSQKI+lZqAFtDViqOsmiNFZBszZJc/bFCd5BLTEJMCZhgST0eH24Q4QIHykw==" + "payload": "Ah4UWbKPz9TWuqaf0mQREs0gmAWMQq2yCbqFYzuFYY5t4R2NXRKibTsGclmuP+cn2GIek4TnYJB1APTXBqJM7i6ie1rsn5BNvybyzyQ1ENqSq71THdPU2cclQ85yxvMuhjGIQXpMTMx5ncoJUd5QFf1rBvyitL1b54JMceFvAk2Gfz0VotyAyl0nJr/IQtKhlSBmoXb3PXJSetFMAsLEAvUWXg==" }, { "length": 255, "nonce": "335abeb1a24fbc00e9cc5f89cd10e86ca5bd6c2258359b998c7c6df0e5aa54e2", - "payload": "AjNavrGiT7wA6cxfic0Q6GylvWwiWDWbmYx8bfDlqlTiUKTaqhGkJAT6N4XpPCS6GmodFRQARYFskIPdjmIyGWlZDJyu/mI4vSiuhaeZLj/6YVZVWOOqOH++GHWdQVx6qf+wfAy27p2OMKzBju7ixUvX7NJl54ra8hAnAApLENyUVVeC50ggG4KqdijmyHyBcLmWEUAH6dXaHEAFH0EW7ESVztsaHpW1tWEfL4U4yZe+U5WD4clVMjJtTy3m89IL+YemvmG3Nhpo8oQtIq1Z8Uh8kZruQITbtVkpOTNSi/7Lh2wSvPTRUrAHas3CYTmGIJMJulnR0P6RwFYnZ/b54a4UOl8AWU64//wGuWnqZn1fyYpeb/L6dikn3GDLQjKpKjetQ5h6QSW+lxxq6fWiykyBvlnQdp5sa+p6a/K/3hu2CL8=" + "payload": "AjNavrGiT7wA6cxfic0Q6GylvWwiWDWbmYx8bfDlqlTiyYZL3yx7qjzbAHozgYg9ob+xpfWWrxmkqkkhitYk2M7GpQVkLVP184IIS065mwP/eGS06smKEzhtRg6jndwS7t/YPapvG0tZk6qQF4np/d9d7+Cvo0e14RjgAfyxP6aRJ3awp748dnwhqFdHap7R6tBeuc0grLvoeQhgug7nQ8ERazKqNOWfijpbjAHjdtZz5e6Nasmq4Am0dnuakX+77ZGMWjnoptacov/8B/1vwA9MWans5dFf1TosgklUOHYHL6AdWa7MOJ2dAAWPONm3SdXMVc7ov9b5p4+FfqiG5l7XoZhlNMsLEsYgrqKQbW1TnwOBRYggzRrD9uCreLk6OkOyB80V/ciddDSNfeAs3r+Ou9StEeYXIF8XkMI7RGfgQjc=" }, { "length": 256, "nonce": "a003d16e5681621eec12cd4d490e577083982c348a9ff0a8c79e5f49b8daa588", - "payload": "AqAD0W5WgWIe7BLNTUkOV3CDmCw0ip/wqMeeX0m42qWIl103kvF19fzphhWzw/+KydpZq4+PGsP6o+Rmof3E7S07MG24CtP8AtvmIdX0pbB2QrVGlfR7IOWv0P5sWBUs8uDEXwxYGized73RK6+yxMLYb//me2pqdMJvF3ebm8devg8ZJqEm2O23kPSow+F1wOXNlTgJhqKvGynAC62Tub8FkyRjCfamdHQ8ZBjC0WmPiXvPaOUcIBL/fcjG1n8qf8JooAmKKz55LuGDP34nvqzRsO/k3Xy9JVCBJVp6EC/sEsD6u0yIhgCOfJP7XxcxMgc3SoAPISi9UIK4lcWkg0kZu56FIUnx3POVnGNvNAyeljjf1iKA+jrgx/kUOEG/lCGon1YN5HflQnEkEPidYZ0O6ZeqD3Tofdrr0WC4sfUhgBY=" + "payload": "AqAD0W5WgWIe7BLNTUkOV3CDmCw0ip/wqMeeX0m42qWIcXkiNdcATXBGaANkpBdIHu284Meme/+8851h/sxjwhBjrS/EJocGWQbOgfQSDXCKSg2X4NmEF2GDoiqLvniyjJPnOpqAFRZ2a3KJ5LKvhcISIN0Uai62zctmjDOIRPx8eT0iYxPoru6jKICVIsHgfdDm5QkbXSjgbsHxvSPue5V5TbeWoJVD2RAlGA/oHMWZaDINXS7SojkbZ0/X1DVd7PsqhU0tnHYxIcHA1fKUeUxQ7XczqMFCgJWU+4LUOoj5P24m4T9TiyhrfjDnDU7CPIszmRz8JAchecljDEHq4WGQAMCDjWqNKxMqi68SxKIC7pXWP/SoBqos22JwzSjeihjIEU+qPBnpHUHlUjPPctZM3EM5+AxGwjDo7bQL4C4h6+c=" }, { "length": 257, "nonce": "59605cc1c103b41ac91b2334576a322015bd170b5445ccff345961458078aae7", - "payload": "AllgXMHBA7QayRsjNFdqMiAVvRcLVEXM/zRZYUWAeKrn2fga2OmC9dyrp/JxMPOKurLvASHggTFXeKPi0M+xk9Fe6kHNBx4sQFTut7Y3wG9r5GBxDn9wfQCQwRGn76AI/9+S0YPsyJojHhabMIVi9OfkjvvdTqZHuQYaTSrBxA7TgkV7RrLrqqouy5xmFglW3YIQ9qQ7PWtG7w9KK1qxrSSCwFT778vb5RAjSZj6KmvQIowP4Q086Ag0vkMQFbzI8q2OyXw/2PhiO+Z4xrif9rQWkvcf8QwHd1Kb6TQ9+1xgZJR1a0jtHTvUWHUlRQU/YvvIRxBuagPeIpoF2LU47Dc995eeBMY9qyuOZSXHGsPaCCKs9i1qYyHBifc6/nZYvIwFgwoFLglcKtBR0LqYGNS+tH1itEaoPTcOUzVcuobOlAVHZOtfQxoQPwrOqYbq+KmVXaAc7WBitD3KvTdZF14ule5qKbworRHz3fEz1IWBqTeSh5fEIBCoS0fiAVjFNiCW" + "payload": "AllgXMHBA7QayRsjNFdqMiAVvRcLVEXM/zRZYUWAeKrn0I/CkUGtbpZ4j5ai2GIHWrbBf+Jg0al/woExFIghqIqgLvhvOr1WhhSEK1K9gSC0j8o2Ot2yEO15kHn/bsjeo/Fz1d25Njy3RyB+OlZRETCYyEwoZDjwzTkjhF0TzvmV2yUmehjXGtkwKpiVb6huiT5UVMAEu1WGZL4C2GxdlFusSFzQckygLUsTI4w1EXvlmHeDPz+qkRbA/63x3s9e+UrP8gp9uU40f5ffw40Rd6mpUS7AeAJCYMrPECvIfGK1aBTt3g+Boq3fq20eFSWK7JP5RPrqzT1Me4wxKNbj91UCuCZJYAPNNAww8NFcC14H8GQV+PCtDG+lCWVmAjBfF/gkedhi8l6jUub4TY5cRNbnC6rzgytNxahXLpZYXq6pGR4P5SssLeSIlYFqYUXnmUEd/JT1+1vcukCua+WuRrx9Dl5/mtBVb6QPs9wIb+7YvSejEDWg8vMfJjo+Wzrr+itc" }, { "length": 300, "nonce": "cf4e1221060f7345f007a1b147510a718df7c812badb4d42553a2a01ba923825", - "payload": "As9OEiEGD3NF8AehsUdRCnGN98gSuttNQlU6KgG6kjglQaAElEi5m88R0m5uuzU+eYRXbDB1EW+ahVuWd/Kc90JzppzRsrUAEC93dDRdjUp4kufO+WxK1r1oz/y4tl/Q6Y1sG042/b1Tdr+2kpARmGO5KxpUKXYue58xK1uWVoedCliVCojucocVzNbCsrBq6utr4WzJl8rsyswKzV5V7kHFcAgkkL50XO2CSdcFdBcCY7hLekZPi3/wahV6bsHrBOlKBpkWRe0bsQ0jeyQy7eEf9llI7xKnSWXA03/fJEoevBJ7VsmAKBx/SJoHz9WMZUzqc8dirCIsD8Gj0J1+ozrEKdBssA6XECZF1w8a8A4+bwig6l8yQPw58qWat3DHYupfC0kgGCciqenLNxpI9ec2Cp+nnA1YNwiMt0XMETzJOm8ocsDdmJxu7ZRCRAIriRPwJyvAE2i9vD1WXMv1Rk3fYrLY52AaNqDTWMuaidXbrf4QpiEIGxeVrQhme7u4kGov" + "payload": "As9OEiEGD3NF8AehsUdRCnGN98gSuttNQlU6KgG6kjgl4ADubizzwYpz9/SN5A+/50L8xWcMlhc5bHwviuAD50b6L0rVkbXPV4EREbfX/c2M0Ed7HiQKQUglFm2HADbPaWGOqCqnf+duifaEoYyeSW7G/7fjXBl+pPYpb3GVTju7NTGzx3XxlGVXiuE0OIh9N8jbzRUVYLan9HtR8vGEr7oKrI9jAjF3hVmFbKuwk4gc1NrtCFp8qczRuVgFZ/8Qb82+JRo+hF0fxj8KpMo9eH3Zflk34RtQfjRtSLAF0GDIHyHC+ihbKGtWGR9CgbfGfzU6/DK5zH+v+1Z/ftkMTAxL6Q8FqLtPc9CPX90q7Rwv9zOXHzemk/oQwphBLVM7aAy3jj4AXz20YIiMBc2okqQimgHD7F0DDect7v0JSqVHadnSCMNXud8Pw/cKcgaZND9NwiOC3PjV/2dJV7vdEEBssSBc4oPe4iD4lxJVOY7bMCKjG9bIQti8h3PO1SyYjvj/" }, { "length": 1000, "nonce": "51d3925d76bde2b2d53a2b8c285f14f1870cfa3264c6c209ba84d0758c3a2249", - "payload": "AlHTkl12veKy1TorjChfFPGHDPoyZMbCCbqE0HWMOiJJClTOW1I2+ccU+Jftmryepqubm+cZ5YHGxtoUoqgE7sUfOeBNJY5jknx2tLiV6IOcG4g6oqbP0OGM0+YmCVXPmb+d9//MmZlQZFMq7xlFn+cVMLKhtVVNx53rrMJuyPBdb8aGvXEqaHmhr0XwBsqdn4W2QeKE06Ef9kkpWwcpZiVoAJ4eeTEg2brXAp06hfFn9smBk8GgvOUaJmaCBxVD7qgTRyPg7S5msNV6jjJGfnr4eRdfSrMvh53HDAXOf0DutphSznXv2L5F2EE4GzR+SLw+JRr2QkIyPNOIIDNuvFpjHlayS3xOkvCW39ppEfDzwXgbBAHhQDBBQ5MAtn5GJvoZr87IT6TY88a3ml/HLUkazfebKJ/72xROh8rUA+2KG5E0kxVgxWBbrCEAOveZM585AAXmZ5dzmGZfH7U1/xfs8QBJSRPFVMpukkT4MapWVN8hTc71tOVBSXAsxZ0rvEw3hDNjrBjCc5p2tp/jazgN4tBB2mZhDSh7DuVgqE4y7Bh0tHj5+HwnVkXmnPH1N6kQ2QuIa6AwtB4MbdOrvRG7xeZiiYjJtSfnznqvgeQYViuMfqHUqD2t0C0hO37ao4vWdmbyQ4hTY0bQlbBpKtSGK7vwEcpFYN/S9rfBbRbgDtV/BZ4FSssy7nmtBhrVaPRb9ooko8GhOCOwDP/WdDSmcJ8xQwYAXjWxIQ2z948oXBJIvDPzAbzBei+cixgES9KbRk+umQWYf5Da1Jr58rU0Ms+vrq1TMTgMjEKcQhIn+i/X9QDq6CnefCaxP6CXegyZzBuIGJo7JkSjTupiPNFNP0Zn60Z0v475GW/HqJKXcHEqo89Myhf84JcehRuxrYUHC4Ra3r+CTZI7JF3RG2HStSkGPgpcDEg5jX6vQf/xEEwWESkHrzN5lNqqyQPQ5omt1LhU3V4cgUyMbx/G9vegQZN4BZrudDoSzs9XZZArJGkNpFdt6DRv/td+TekM37OcjzMNHOznMEuqcQRYuaGVP/S9w2kww2uVok4kV4rIJzAsIw/9S3SRwdDLWSS3SwQ4WC5OGJmoSlai3OxleCghi0kwFxsiktb7ikwwE12NkUFyWIyX0nSBOfzenhQkjj+TDYLAOKsq5Dp0AN/f97ox3sIW7h2kFBoSkg0V12mWzXrWTZSEdMhMlFN7ofXxnJ38VzSRuYsd8hJn055phUEAxq0CH8sPq0sUXFPswecQxFH14PICTkWcY5JyQtK5nVOmzlz2PFQMlmTBkf8zDq2oPavgQ/lKyJVplT56foV0j8uymw0iy+UXC/xVJvHI7U/17TqlFjQBVZPIm9XB5CUZjWZHBv24kvRD4YXMD3KRTtfOD8Bg++BGbRW7+1DjCMCtsYeVictA+/AiENWJGJDo5EOhSqm6eJ993o8Xxb1qBTg=" + "payload": "AlHTkl12veKy1TorjChfFPGHDPoyZMbCCbqE0HWMOiJJPxAt9fYm4XVN2J8lq1JE/VYIj3ECxLebCKpEhP69aK7DT+7K0kUyE/rbhgPhv8mUCB2cvposZkFDYkiH+2915d154DOhW6w7pCZO7wNmCyZy+2su2lcNxsRCGWaqAW9P4tkxclljHVJdb4/qhlPRtrJbQ5nNy5hTwQI4tyIJ8IlXyUEIl1tbfMZ3bV3I4y7bW2pRNfTu+Wruk/u8Zs9Q2x+R/+IDqIAEs5zobdbPWbbtIWGfdSif6EU+Xd+mhjQrtlQecKaFBuDzz1Wy6roeZEqtO6XTHcj2Yimz2z4sJ4C8Qi+2j6F/DDArR/d8zeUHK/LVmVJcJu5zJFNWehq5jJtHaZcAS1Dt/lA/75vWrUai8SL9Yhs0esdGw6sBWHqC7v9Xana02CU2+zEfhAJWYDjPESmG7q7Z1V3D8fi0Tcj7K/1nXFngIDgsTWdUf1RNfm00xEDpgvGRwy7q6ryG6ike1q88Jq/5Mq/4DGNgysT8TP1AuL8D57Pp59IENINLCxu/xBHDUD6NGLacj4kU5hazNs7W5VTzVafnaDU80pPlTl8Wo5/7hEIK2lbBB9M6UOUFAcz/wL/7iO6CpwUnNoaEk9C+/F3hGgKuzPPFEHZwa+raVXLYBim2vIVaDolTuYP1cycv2FI8iQizf284qfWKw4FoOQN0L+WN9ykpB6Lro2GulT/hepw/f9/IbM+RI08LYjxDWnNKTjF6qafhyovz/oKqyD251zFSVv4Vl/JbCOmngAqsmy3lX9woMHmB1LsLjUXCAx9qT7mBgxCCF4GVMfEBznYPPrNmKcQ5dhiVZn2evi6yfEMJsE5oL/z1Q3zrlutbVugZUt0SzTD6cRz0UsAYSkuBV5aDIyugeTM2m8/KLoXBv33zQYUBmQzN2xS/QPsMawZ0Gp6BoKsKT3nt+u5m2oVRQ0DUdkhVUmAqhQJX148qPZL9u5ci571zckZmZU92G3/8eClvUSzalOv5d1q2gS9UlWPkW0ekDKbo6usREDU2LO+45gGl8k7DdMLldPIkvsrMdy5I8xZ95pHVL+tsn3tjUdLLfbv6XpBVnMTXs7N9F1+wb6JaqvcbDO16pvI6GvsxQkF39JM+CGEpoCO5s3BzOLp2tSZqQyTkNhSrUtxxeUz+smJk+Z8w0PCywEKm/E0fg0zQBSADVPF6+Dumyc98qkzSXfU0pQxDMG3DLDA0clGVNhAhVmSFEqPKVzbk1LtdoFPBZcmyxo0Kkf2JmENVz94NiKhTVkNKnC27jtHZiDILZ4+TniYsn8tVfTsltedA0osjFtMRx4Ov5PvOwvfNrBVAGu3mzR4VhSnwzxTI2LtzSBvbgC3bMX7IubvOu9/dBrfsmUBYLoGYtQS687HXhecdNgkPzVzbBuqUAogHrNuCoq4TJ1Hu3V0=" }, { "length": 4096, "nonce": "a20a6255ff310bf92ad6eb8688687b01be27612b2826b2b0f158ac9c7a75c4b9", - "payload_sha256": "e6614fb0faa055e0cd02ddce20449d0cc6f05fad7c0966822f03890238e6ac80" + "payload_sha256": "47122229feaa82504d319e6bca7728fb0ee75b895d71cc1b59b26eb548c923d8" }, { "length": 16385, "nonce": "ff3410c7c0b3ed2782d7e27ec7f2b16ad2716a8d0ba1506cff2717cea83891ff", - "payload_sha256": "6b5b4c0a34626ae72241921247736138e8c04b64e0f27a06a691326a42e665d5" + "payload_sha256": "de7c390d74f9f94155fea91eac00cd3d9b4f33b564712212151c1a7df7e661e8" }, { "length": 65408, "nonce": "bd7fee018080bdcaf386916c733834ada1b438b8341f24dd9328cb983eaa6a94", - "payload_sha256": "f198aefb3f7db5d05d7bdeea023f9483a45329ce66da79b91b097e42061116b3" + "payload_sha256": "f191268880e0b4ec2539ba22e3976435284273b564f25a625563ae419558cbf6" } ], "peer_pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", "peer_secret": "b690c8608bd3d48ac4f6023b22139fc2e622dabe720b0699df144f3c5f279044", "proofs": [ { - "proof": "295deee9387316b3980c93b7429003a0e30187773c8cd4a6e64f7814c078e2bf25ec232150571f84acde7a9b7ff10c6c62ec3a12f6d5d0c11dad3ab23a0e3f83", + "proof": "d0390ab92a4fc484a588938db4cb44efdaa3dbd31f3cf0f9db99ea8f82a97415a6ec3e3e9c1367bd2d7f79d621327f5daed5ed9feaba2bc7fc3c845f6c75f1d4", "timestamp": 0 }, { - "proof": "6002674cb570df23e93ce69bb92eaed7ad2cdf6032bf33a727d2b54df57889d5b2345cbc451547bbad367bb24becf81388311d205ef7eb3e319a724ee8ecb0cb", + "proof": "5058367c745acdd8c634acc4f7b0c569bd738df876cb2ad0c5480c73d605885405b7cfbe247125e7651a2b9f5b98a0002be2ab68e09d230bfc210a1cc3bc1363", "timestamp": 1700000000 }, { - "proof": "d84ef2ceae2ab60a58ea16e9f6a81095347996f5f5dbb7149dc9ced6b5aaf14a8fc7d7d34072cd1fbf3e05d20f392f98bec854179b50d60045ddd8bc2c5493b9", + "proof": "32b4f8e6d029d744ba59640786ea75720cfc4aa7a6c411697af6bec413d3f500c92e4b3f0f7e5cb027f5c440632585a586ced4e1638a5bdbd3de55253959bda1", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "6d9337adb5a9d02c3a37f8f8f90abb65bd45cc95ea0a874df888fd0a2d37c62d" + "transport_pubkey": "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":3,\"verifying_share\":\"03403a4eddd79ffb0cbe53a13602a8cfa4cd0f36811cd05d7c87176863dc07ce13\",\"proof_signature\":\"a865875e92e464000956bda68754daa4bb9175b3bff8d431aeb500e67d15a22fc179af7a0e3feda41a80d1a21a5fa7376f4066f498651210154568d49789d394\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", - "created_at": 1791465430, - "id": "18dea5a4d675527285d8886a775670f409b19aa3e2dfac96dd0252cd6751c9f1", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6\",\"share_index\":3,\"verifying_share\":\"02c9943ba6a56c33ebd33a8420f1afb013219ac5ddc825cbfa521b4966362e469c\",\"proof_signature\":\"69fbdb620dcc9068fdcbac5433d66a13bea6d17c3eff488e4fb86fe8e4c106ac7321f321f414c989c744e057fcf6a512e58281acdcf1fbd884580badfcd4053d\",\"timestamp\":1791467352,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791467352, + "id": "c1ebfcb4cd8d24256278d7cd0ff94e8ff0c24f6d294583eda60229a451589a40", "kind": 24242, - "pubkey": "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62", - "sig": "fe22c7f75182bc4fa4c17ca6dc830297c2edd1f0622434c090b2a22db440015067cee8d8e418e7f44491b98a2db91a0d6e636bf72b8f3283bb1c38b6faadb684", + "pubkey": "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770", + "sig": "8d91b58bb44ec3bbbe74aa90a7619084528affe04c44b15d3cf4618c4ce39433f96e6e07ae0565266ee97098267aaacee11a161329c6e785c49fd4433cb06f7f", "tags": [ [ "g", - "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" ], [ "t", @@ -1403,35 +1403,35 @@ ], [ "p", - "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" ], [ "p", - "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" ], [ "p", - "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" ], [ "p", - "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" ] ] }, "events": [ { "event": { - "content": "Au2B0DTH2+zaYDnz45WRRAbIFIYqKS2Nb4oOvOV3s7t1aKawdZHODzWia7ei5uFw2t8BRVoz2dtYxMByQqvZOueCujkM6qTmJH0/nSXJVZRkKspEwEw+ENQ8fCZA8ZqOHh1+4QH6yYIf0/DUrm9Lnim95wUsvN2uvi4MrrFI1G2wb8i+bH3EjOyrTkTqhHHOBCUye57ZHxhPTFMECeoH80gdxExQm1hgtG/sT9J1aBaCvqU8uCeZmyyAC68EarRdarzG", - "created_at": 1791465433, - "id": "a87f6dbe5be1f396cf532d155de6ce2ff1d560bd0a5ff1433a722b336c0b59d5", + "content": "Ap7ohjoF+Nc2ZA33onfl+pvo4nKPAg0mIGo5HC1NhT9KbvIfG/ETTpecIkj8PELi15AvPSXk1SyQfuCuv1hNd6PIYkAzaRDkFYnNLj6fRcbabMkAIFkQk+E6d7tWxh1j50XPbfHKgnYjsAUgpz+xy/K/vIuAJeRLgkzNBGWwELnsdaoc1Aw+sA90o9tu+y3dtP5fyELc0zrZwEgFAOdRDdOzDLgFjbrGsDna9seMb9R1ZzVNN7ExCWcERkXPCecb8z5Y", + "created_at": 1791467348, + "id": "d2f90541bb5c316c06dcaf9e5d555575837b1f7952bd58b86c832cd6f216a3be", "kind": 24242, "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", - "sig": "3cdc246104ba79487603c82d84bbba19db5eea0a6d217d0593005e41907cb117382e648f17f7fe0843b1de91ea265263b1132099e93aef39fdffb496543ea857", + "sig": "28d6377d1453c0e184d3959207eccc407d6575f7a8c058a103b5a5ee77ee2132120d0556d281cf439da2440ab7cf9be785845dfe13dbecf8e21ad12aca377a4e", "tags": [ [ "p", - "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" ], [ "t", @@ -1439,20 +1439,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" }, { "event": { - "content": "AtsT5C/FsnbDF4mxBTUhIuGB5YVSbbvutZTOe/pVmdNU4sfzb5nX0aCj/lbQa5Ivjsxi9sAEEPDQpifkeB2qxE74bAzPaxqusYWc1D34jnuIh0bKm4aerrcXF1Pwaj55HwTgkRexAnbA/O5lI6hPfwYgDrGb0GdyIKaOoeNPwywTA/M3iEAFtnxAMr6jnS8Dk1xBUZYXVBih3S7SMDuS4enC0emGG1LcSs/xcvzasfyGkK54mL41TZM8ObArmvTl2IDA", - "created_at": 1791465433, - "id": "6334e6197da3a9cccf2ebb566d8869be22a02d9bcb5df2cf114bfa1ac491aaae", + "content": "ApaCwoMEa9aPXwwezpBVcuSjDniF77ckucw9c7Q+JLQyCFz0tNc8AAYgycqzyvyAadH2koHHayKa/MWcEfRo4MQXFFDHaqZreukVxBSn4CK6VidFaHrwnMGxkMZTl2f4WysDTDe6DaUrTIhmR3MDQ7c+rdFiXEePl/VzFcoorHEf7ZdBiV2NZcJkm93fIX3qLvAP3CpOerTOKzQQGyDwhZYLC/AOuI551TJ7zcV6Rcf57OdVQI9WIJrZfcDfG+XfHOTa", + "created_at": 1791467349, + "id": "b231faad2c3c910fac7daaab86faac51cbbf5fc9f8c4b25872e1f09610546501", "kind": 24242, "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", - "sig": "99db0a5e51bd14a4ac7213067ae1fde16850004859f9f4bedf49f644745a27b6c8f9bd9f3d48f3b15acc0bd36a44b266115e310ec886c2d7c970b3898f30a880", + "sig": "5075d4a7a14ae402e6186a690098ad0a70e95ebb9c8467b3650d9489156a84bbbd6f51277ed06c5003ff3905b8a07aba7784fafd2db174f2e9b7750f192e9daf", "tags": [ [ "p", - "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" ], [ "t", @@ -1460,7 +1460,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"71c69a4b8a6bf0a41e2b862f1c6923b548ad026473f03bc204aec9b841e3f410\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"0c7119dc73a14a92556301204120610a3fa5541e530bcd4182d8e9b45b75a21e\",\"timestamp\":1791467352}" } ], "index": 3, @@ -1468,109 +1468,109 @@ { "length": 1, "nonce": "730dd3b666c8ae9861d43b4f466486879373c9e8434ae346724d954d64370640", - "payload": "AnMN07ZmyK6YYdQ7T0ZkhoeTc8noQ0rjRnJNlU1kNwZAw7zkZMoKiRiTK93xqAeb7QDuDRcK5IYd/AsEYFpNVlGfcfeqKXiDAyWOwrWTqGooD16E6AZAxMYjo7me9KJbhaoj" + "payload": "AnMN07ZmyK6YYdQ7T0ZkhoeTc8noQ0rjRnJNlU1kNwZAhDJebKhYGMJ/N7T1YU1SEQSGbl3BzFrajMpHGjLqziacs4UpByDMApY9Cwt3V10SUaDvsuPsWHuXiNs55f9D/vRT" }, { "length": 16, "nonce": "556a283834de1c0f4a570705f349c063225841ba4db5ff808f39e0b8644664c8", - "payload": "AlVqKDg03hwPSlcHBfNJwGMiWEG6TbX/gI854LhkRmTImOzJrym/EP+UcmofbunEs1JOCmsr6i3OozUx/l2HvYHbJfWC1mukwGn290W+Gj+aC7TuOItD57LqE0c6NQ23qkBG" + "payload": "AlVqKDg03hwPSlcHBfNJwGMiWEG6TbX/gI854LhkRmTI4JGEIV/IfQLjtzFBKbQmUj3Pd8xVO4zU+i0k2HEFHWJie+xRVghRT9Re9hydBiQDjgV7B2iSLdZdsgSEkc/a/JBU" }, { "length": 31, "nonce": "b5f284fe48ba8a0a95bf23b4f485a14602367a18735978e396f9480c066489be", - "payload": "ArXyhP5IuooKlb8jtPSFoUYCNnoYc1l445b5SAwGZIm+cVf9lU8sHM3Kk7ipHeuHckheRSPGxcNFuOUEXU+I0TyeFfJO3SJhTmUA1DyzwhjUvnj3hTeHrij6YFrUxsRChm6Z" + "payload": "ArXyhP5IuooKlb8jtPSFoUYCNnoYc1l445b5SAwGZIm+lA2QarSs2bD5j65+MNtnQvxJbEF0uaQu46p/rUgaDUbAGH1F8cmAobCXAYuurGriDPFlkC3eTf2LtK2Q5iqOoBvr" }, { "length": 32, "nonce": "c8bddaa582eece36e64e0b80799bd6df095f3b1d42aa275d787fb718cd15f985", - "payload": "Asi92qWC7s425k4LgHmb1t8JXzsdQqonXXh/txjNFfmF+Le4EEkSwZOJxO5fy041XroNZ7TIZj/VuaOo7Bx9QJwVqVx7o4hFyCPrsYKeZYB4ViufddRUO3hcBGputAGUjBfG" + "payload": "Asi92qWC7s425k4LgHmb1t8JXzsdQqonXXh/txjNFfmF/Mc2Nq6mwtUGXe4K/enSCY/6Nk5/aCUb6KnpSIkZXKepuYQ1Tc18Cdl9Rc8SyvaNYb7uu2fx9gsl/h8xUgrLQWzJ" }, { "length": 33, "nonce": "993bcd6fd5457832884c0a4ac16538ebdba618c0403b4b49a1443571fea23027", - "payload": "Apk7zW/VRXgyiEwKSsFlOOvbphjAQDtLSaFENXH+ojAnxW6FhBUqjv9PiY44ML12VBfiTpuuCt7NjOUQXlcXE4lPPGMW9RulF9/xSrjazI/bywMViIBRR3gjCkW7VEVeJ2sGR20Gs1Rn4eWTo0Qp8MiiO8v83wI+YPe5DRtvRIzn9Rc=" + "payload": "Apk7zW/VRXgyiEwKSsFlOOvbphjAQDtLSaFENXH+ojAnM7MNldpebEFE+/UCGPqkyprpCXPOl1LDVWU9r8uVQD4CCT6MMmseptH7o4kuZU7lUvxerZzDujI/ghbcMdsMqWOZ9hvifmOQQap6NWOpIGabnHapSl4YGIwHBAKAB4x7kyg=" }, { "length": 64, "nonce": "a386047bde1ee137f258e3957a38540788805564a7b594514ae826e618d4321f", - "payload": "AqOGBHveHuE38ljjlXo4VAeIgFVkp7WUUUroJuYY1DIf1IAYsoncsx2K1z0fBkZzn/8UPuMNEo1NN6nfXbROS/e8DQO1OU/S8hVk85iR/xNQ4z2FmcSotTYPmOhyrU/aF3d+IiaEnQ6fZXC8Rg7hnNi7+UkkoNuc+IDYLTkB3LvcNec=" + "payload": "AqOGBHveHuE38ljjlXo4VAeIgFVkp7WUUUroJuYY1DIfRariI/U64SBW+PK5aRdroADeF4+vRPAqWbckM2gq01Lk2kQJNDsKt70npmySQwP53AKEI2hGe1Z4y0sPGvNHd/NnKHbRoRy4lLi6io7vslwFGJsSaGeA5U6mA4CEXec+Odw=" }, { "length": 65, "nonce": "da1b84a35ef0e40c6561bd9024aa3a6ed6712126de12d1482169a2781c44fcad", - "payload": "AtobhKNe8OQMZWG9kCSqOm7WcSEm3hLRSCFpongcRPytoXihP/7pA2jVA3pVeHZLwiNRlIniTR/atUOrglUSOYtvdwmyi7zcqntdqjcnsTSvxDaBCEEp3ueJ1aWwyOAkseyP+97oGPdSXoDtTMTMwbvxlqp0Fz8DSWJKyIV3qY8tvGQbt/fTtLOhGG0D2srB66ZQB1lF3R5oAUfK/pBQtzyfMw==" + "payload": "AtobhKNe8OQMZWG9kCSqOm7WcSEm3hLRSCFpongcRPyt+6KiqLttNRsP7mzwstyT6QfgFRWtGrAsj+037VuKA66ujCuhURs3S46PH9upiDYP//UNcHr5i05DHVgB0+auuSdBAB+akDHQ+1wr1x1hhvbnewUZbAZDPngrjJmtDfLUlzrcIQhGgMgzFv2WndEATaOQR5TKYLlEFT00mD5pM+tgVA==" }, { "length": 255, "nonce": "a0403f0ed608ae7311dc8ba0517e20f787443f0f611c740c00208bb68c88b387", - "payload": "AqBAPw7WCK5zEdyLoFF+IPeHRD8PYRx0DAAgi7aMiLOHN8ixz4ZltxNauVZbTydkU1azCUbfCIRx09zya16YvzDnI1KsuXz4Z6McmeLF/eUH+Sg/D4lwad8i/M/hbD0pxFH4E5i/sF3Br9Kjrx+xiJD85LdY7jZOh77jl5gnKwAu0YgXZnaKjVo6EDeTxxayV+LdR4frlAJvGRVd3eZQsGKxowI9bdhYTaLWFM359yNbtYGdoBwHJwOsPR2Q3XT13d9kCGVcnUw/YfzSYYVHP3Fvd00hV+kW9JfFrACGm7CuxYVm1Mv3sz7d0EEgUu3cGZ8CxW2YBT9bvrcwBjfEYUKCSgI5i7QHS4byTrWzl8cTw0q/M9onql/T9khO2FWDmrOeUtOZSOCvOAWS5YyqAYzwxhjoZRb7QLBz+bNvoR+a7zU=" + "payload": "AqBAPw7WCK5zEdyLoFF+IPeHRD8PYRx0DAAgi7aMiLOH/wqPzDM1CyLEklFCOAjXbr0SZu65DJfIk7Wmja8u49jqipOg8e914wZSCl5QCoE8j6AtbQFk2RQdYHshJBwUU3vduNnm9AvR2jpqOLaOv5aW3DQZFt1pOcUvlLSbbPs3k3payzH94yjnfFyRIX7/Gwbb8Fm7ppWzr+QGUs3F7WXgli/VdUgbYyRqJfS4XTUlDT0m2JPapA42bca37NaDkH17wauWZpuxxuUHWAl1BrNJx1ApXeZjbGv7eoBeawZxTE9v7WzjMaVMSbVa2ANZNW72Ph/QftSFzMYhdO/+CqOdsRm+phLd1zHIM21wsncNlmVxVK5OrP9S1Tc29V5AIrdkzc3mbqSfqVR1nScr/Oeo4sDnexkyE13AtmMMzlOGIq4=" }, { "length": 256, "nonce": "935054aebf3273e871dde091e67de813980e584021594516f2997877cf65a8d5", - "payload": "ApNQVK6/MnPocd3gkeZ96BOYDlhAIVlFFvKZeHfPZajVZtlR6lQupwVn9l/9BkxcXBYUsFq/U49MMu7N2CGcv08/9IsM14E/FZQ+n6WMdo+mdwXmucHGyGP32xZYgtdt7lej3HyalxjBh/vrOYdGslhQEAOdslBOSCQXBP9u+ZLvh7wpkfmEXTrQY/vISFRRzoC8uYyQPCDVK07fwwcTqntNKCdLWPU5LZDnx9zKdzVOzfnBc5gtsJEXxCVPQR+e8HRTHM9SXh0l5EQfStkcH52LJrwKXoHst2gXlXFB01QnCJyk8vL5IK2kueNmarrQMQlmdJ9sLCosWIXcr3QJ6kuL+dulyBIrKBhza9eGnx2eZIevh7elriwgDiqoq4yJNTDSQrrOtf1JjOlX6pgTjUBPXmm9zZHRrKj7dPbSNCG36MM=" + "payload": "ApNQVK6/MnPocd3gkeZ96BOYDlhAIVlFFvKZeHfPZajVa0Dxc+DtXmrgtoF71ZBhQ8P9tt39BEo29/dc0UKi59AS5sMsrCOQwnTyRdiNqK5lEI1m33d8y+sT9nptoiM+4E4OsS4KVaumjZDwE9Fh6kywXOjKJ84J+K/B+sQw6mbkQ9NycKMhVkpXgecvZG+GgM7q+kAtvaQclmSA+mxXYEwOM94uKUn1hza8BZoHH3zu7emWNAOHmOzmypsTS6+igVtCHDO9gz0jT+SCvs5eTeQotf4PU8oF2AETcj6sLRG8BhjnGTy3xVR9MGjy3YQQ9umkraYmbj+JN2/sTRDn9I+7CE00OsGKtDm0iZQbpdUK5G+0+qTu08zB5vXkwl3m8/CaagH8SmJks/RP/WvFqw26wzazhUhIBi7QiiUQCGwr/RI=" }, { "length": 257, "nonce": "76b739a3fcb1a02e2052587c0708bf4d50c56a89cbf850e02cd892a21cf409c7", - "payload": "Ana3OaP8saAuIFJYfAcIv01QxWqJy/hQ4CzYkqIc9AnHzmAu1aw1bZ807W/TBPVwmOGigt5AKeEmjvURujpKvLUglmas6A+Lg+wS2VW/TCQdFmUFNwd8sxxzkPrMaQ0UVASwU4UZxpxNRvgsPgL2kLuD0WCV9GAsTtz0tbnCvu5etZZjJmOH3suHXGwLnLcWTCwa7F4t6u0YI4TAj6hQ0TDKqWXFmTt6Ba+ggTbVtUNCkwV++8+UGiuNwVghLT5OecZ5ge+/DUa0WIMGrP5JeT+JHzUyKf6BcOx3y8L0EKdQHunQ20xyeEOea2G3raPTDVeiYHn1FoljS90eHOguwgVfSn2HoVwV4gajecWnRykr5MQfZo9TI4/3uBIHCoj7JNPi0ZFjswRXuVhWxNZ+D/aKH6pBHWB4Br/c9APi6O7mq1QL/KactoJqL+0GyPZeTLRZsZOc15ws26l1XFUgT6NgN9U7oH54r30hJvrQDv5LwaSCdMYSI4tPL5JyM+zNx5uP" + "payload": "Ana3OaP8saAuIFJYfAcIv01QxWqJy/hQ4CzYkqIc9AnHEQvX0CCl+goXYq4PFu7540AEXlSovKURSlyWsc5SgXKCQ4louG2MF9y/MYjy4JQmPSEHwFJxcHBNupw2PcMzUbdPjARLrDVAAL+IKFnJ537+wXCqljBS9drIplJq3mCtGeMIaevaqU3vI3PzfhHA3ugcr5v+2wU574PVIktyiZZvT7EIYqu6lv8wDklkZ9x1vhZmYgrl7MTvypBRfLkOZxXYn8aiSLe1pEhlZU/+IAEzIG3ZY2RF41SELn7JHDqjJagrivCOQbudfXTganLzvWaNf8zXOkFo+e1MYM45JN+ex4E6BKPRQPGAXqMaQNwSaLy2aHummA8znzkRfjCyimrPMqTjMx8fPdqcifQYTHonWEWMSObK+a87HCQPlKGhXT7yWwqREFoIE5wJNPxQELZuSngvKfYaGLJk++q3YuaWceEI81stJIllFbQy3pmh4St6jLv3Lv0Ve5zEMkdjXxEN" }, { "length": 300, "nonce": "61856bbf0d107107402beef928a1a615b4584a42b40be3b8ddd46fcd1a1f63f6", - "payload": "AmGFa78NEHEHQCvu+SihphW0WEpCtAvjuN3Ub80aH2P2n1/6OIR/XzjrA4TZdQP42Z5ghDDGuCxmpPTDf43KbFfbdF7TenDFnYed8aaV7Srts8OWJPOTLG4e3M7JDv03qiFLf7OnjtDQOy4HhQMyr/EM7oT671qIi/nvyL2qSwLRoDTWDD4pzWRP4Oq1XB+YLXkqxuWh8XhMQwRGRQ/LLng0HAFL03e29xlWwEDS2vv/+YdEwGOWYKbamUgWMzUIwfeAJzQ/7PoDrMvFS/GUUQHvzf4MxVhDoKMTH/0Z242s3F/YFABmIpRiM+Qxizl2KB9dqdgaqmxhfFeuAPf5gM9dmbreRTFSiTB5pcS7Rvbk4R11bD+o5v2BcumjYAihcVqKKo/0cEXeoDGIvD95NSOf0gNpwAePff6b1Fvt5bTZQiq0bM1TTGHjaifUb7JDI3WTzfwogQgInTZxsN/4TbFoM1xokjXWh8fHWtep6v0hXEUFbjh/Hql6FN1RdAYDq+rU" + "payload": "AmGFa78NEHEHQCvu+SihphW0WEpCtAvjuN3Ub80aH2P24h4kTHFbDIo7yYmgO4nzPpPiosKhYPCC/cl56KQcuYITEP1vBK4gzaL23tpMG77qPZ4DgPe937zrxURXI/WJhA0ZBnqrENdTgDt9P4lQqCxtgYb709rJUpJFoJH69q6GzT6kM4w0Xo0F53bcHBmERW3Rw2kdNtFB6S0OIworrQvs98qiiP2Kk9RvMoheV2J+qOB6J6/n4dYvYGUjMdLIugml1M+m7TLmJ/0m5344XbwJzLDJX/epCYOR6AO3PpJP//DLIMuRtXxlde+BACu9WQdo51TEdjoSYx+BeU1RPaF0F/EFOpu6LXb59TswjWC2JSuPfOLlHO29kozkzffv/JD0P7NZARZ+4yu4lrQoN4J1hx18U64It9pPU7RY9c1TFc5sjvyXoB6bzYRVZcOZG+VT0G57J2aPVl25Ry5qoIGfOmlGQnWPUI6xDdwHn7lSGsuSAjOGdCSihVc0hQQXWHIf" }, { "length": 1000, "nonce": "440f1052d4aa459143ebefab3ac9f1862b83b43b2a30e9c5fe118a274b1dbf40", - "payload": "AkQPEFLUqkWRQ+vvqzrJ8YYrg7Q7KjDpxf4RiidLHb9Av9dLQBFluG7QoPhLVbpUdjn6e2SMYGbOSek0TzAKmjvPM7QDTpKUevHFzCyjqB+HnetQKEm+sIkMPoJSyq+YsAfv1Mr/4e8+NC9vfq6fGXPfCRqR9tCEJQOqBz4gRHeoQQbfpvYdJQdBxsxb3QQtfF9LqbbRxz3j4SWg5nUU6FN1sdJHrWmUCuhwftAbiXHmaVeCPPMNkeghIzU6WzLV2MssFDCrCKHaWLP0vT33oPe7oBjs0eYCR4iyCdgclXr47H34dPFyVfj0w9zYMLYreqXy+zsRHFubWvgOsJoqzif7dht6U5Gpau1CwEYt0bI/e+bGgzuPtjP3UdawtTF6HPPx5BeEFL0/N0WyXY28X87Q5hWZDg7jD6+Rgdm4KSWW6s3GxrCwvL5i3VeTCkB0E6LUpPcUhEC43meuDJ0lpdPg2klvduQUHOZXvbK7BAUF7nF5VudINJnulJvw/SKYgvdQY87Q0qz2SqMAE7uhfjR4vM5Uknl0pDyqRdTyOgka7fuuFEa2uNGGzgi71DtNr9LmKi9o5fk4ZTMiMardnL+movlx2eln7RidxN8DT4AHLORn4NyrjdBqXoOtTzAh666AGudbjpVWeEeQ3G1rUas5qjYGsYAJHFeApiUCI61bbVi/NWlTL9VET2VPNxPVhkOf+qBPsgswfYg7wwW7m8RpE/EdGDacoMtrgIQnWRT/ptYX4U48l559CWYXkL/oOK3eIFb1DnnGJzy/7j58iLDaDJ3JpjN0LmapW40SfkI0RXWjsEZYwQKf9yVLbv+4fixhx8UKBEIYvHTZBNEABp82d9kSICFsxZ/1Zq7uT76w3mrM7DpXMgIVn9dTwYpX/3Lp3j2udIesqgoAfo6WIxWLfSBBWqdOpVzLk45xR3NFOPhcGQELY0m+VWtafvNopbTpYxsIoSVp46y2JjZUWjC3u3zUYxYJ7ZWfptViWghQTUV6Co8uGIDEmp6nk/aLC33C5YjvmOZZWHFuv8ZT1eRXKxcECcqE4HQa1Fl2VfBQIIcDJK1eMQTRXCPWzZxU3UEFabKe8eQ8K7iasGCNxojmHOeUCGbpJu8n6xME077430TvKh2o9Cvq+HMFQgqxJaQ6ViS/lzr8vugivwE3bTP51tw2aSKWyeiEkmCQbVS/nik+SG7WtxlhXVselxFUWjVuAmc9e7xXE3vY/u7RIe0ERIIHWxza6aclglq9qi3hNjypSkAPrM++CbvDRNExj+LtvLKH/ihUD6lnZ6yjcfnCpEA5HwRe8pD8HN6gkD0pbcdHgPPpodkl1E8pfNfnCOZ5sftWdg+BvukBcxXEMEWKqcQ9scfEhaQxvQzP6m0sdo5GsPUgHiXVIoMo+OSeOwucdzmQYDOZlYzFny/hD6SYfyU0bmDsduJ6Cy8fDwk1dUg=" + "payload": "AkQPEFLUqkWRQ+vvqzrJ8YYrg7Q7KjDpxf4RiidLHb9AHHqHXP/Mmt4Nnh8XWzvmcVOPzzeOUYfaFhx5bH/DURgojdJh7nO+OK6FbKP0I863T7MhjxoEyoH/JhK+qxHi94jTnoLAJ3ocJYn+jcMY/AaOrYRyZwqNIkUEevHkrhdFELeeu1etUb3azmmt9eVY7MZmfk22nwLE6p8uXYqm/O8wu5WMdp78IORaUJfUjBazcmukzDwD2HBjuH27gqncCtsr9uRl797jr51SZ+esHI3UmoYTeT2pxI/u3Dojk9pw44obpWMnkBmeLbAwH83SEily3JMHJwQ2OkbRC5w4yxzdnB+RFolHCjks1JzqiDRRX7VdHR/cqHCtJfn6CJE4Vyo3niS4CK458L35qYYLXJzLNburfibaBnAn9mH75RR5KzjiLlVxmCI5cifVeSalFrSF75IqAGjZ6O4l0Nwlo4khl7qTbh+UcYCybnw0CgbiJCZLfp6gErxhTnUcfZY7uSsO+ICcHiq7hX+HGICxMovujVneb0wlpjpudjRzk1e4/4f9+IOeHKsqV6cyDRmGEqrVjJ85U8pmegAE3ZH4ABwOJe3buYcNuA0bncBS2kLUVuYA66izAKTD3tihz+GhCc9aThLW7uqZ6mOMOu1E0zanqfhwoc3opJexdfaA8Qzx1tS9cMR98ZUaj+9V5mai9bi5VlSz9qr4tmriQ2r6+KhangP+J69YafOz48MxMN1oz6CNAPB/9qlMeFzpLw1beybMLlNr2yQ6Dn18hNFsni8lzTGPQ1c0RdsJ+IBqQ0xwm35U3z/9+HLwmpEJPdn8gCy5ZLmdvugeewwmfbCwoXO9cFJadoSOjUyvOTa8VxbqSRAI+NlQZz1z2fwS7oAePeBGOj+5msrj7h9W0I6yJejch0QsGUXVbEUEf0X6YWSYZWnMuBQ88egPjLIu50cg2DkhOI80Bn5zGWRlYKu8jvfWMS2eTr9ITsQWLcV6oUaBg4TtLqBZVa+kJ/o4Mqf2ZjQxI3hHnolI3pqRIUVTpFviP7wneyH+vPYNY0P9SgU2X5CJUrVNfw8qZrPaESAI4THpCEpcNJNXliDoqBP9p2xWSrCp52W5jnJQDzT8VCNLxw8XnsKfmaZTflhAN/zdH/XI0am8lQap/cbEidPI5AHJixbYdZtPYE4k6BtlWSENTM39C1MXGFF8duEBJ3eAjlYiBSw26H4RsI2rmNFlqpFwUKylM1ElWrwXx03mWzh3zrfIMRRGP1V3tkA/wQ9Dfta7mK1Mb+ku6mb3o+TyMrwDOZCIZD8/lGvpBOF8mDuUcj90ovtLmstNIKIsvBkW523ERSZJiNrqWPSMeH40+voD9nD5OIdGy/Zxt2QIf84zdTozXIzWluyEuyw455DVFXqBPIokkY+9znW29o1Xch6uQ44dpiPpyvQUtso7rJC6L+I=" }, { "length": 4096, "nonce": "66a33423de475bedf128ebec41029ea29445fa5d52d0d834286c220a09dc891b", - "payload_sha256": "d9807da1669f746436e309df8912a9a245832d41447099a1d10250fd272edbc5" + "payload_sha256": "d73bb6aec4c2a1deef850dee38f3b5bcd55ae4381b509857762e5e0b13f1a2e7" }, { "length": 16385, "nonce": "bd61789fb7f0238be2ea43d7f96aefa11304a985d41b12b9c5b600316f6f78f3", - "payload_sha256": "4e4d871bb57267782a5c182f2b54f30d6475b6ebe38510cde6c1a2bb259de223" + "payload_sha256": "4565b451e59a189f82aa27ea1220a4a791cc865a8ee8009fb924a66a35dc5b4f" }, { "length": 65408, "nonce": "763362642e9d032d784b56997603b630b884209afa1deb539b2863f1c4d62167", - "payload_sha256": "5f1660508a52ae07f82ba1b8f6b0d2fa95fa6439e766ac6f4b725cd618a71408" + "payload_sha256": "0f568051e9d26fab8ebccb00f7342ab00a6b5b87ed047f49d824a435e9f50464" } ], "peer_pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", "peer_secret": "9564324958c336ced3cbb1d8892a8fc5d89604473194e457a2fb400456e6a7b4", "proofs": [ { - "proof": "922573ffe9f4b5b110eaf9be75c8ce48e86d1641bf99bf4848e863a1fadb0cb0ea0d33aa92725d8e3788eae9369a5c959e85d211be1ceb0935a1d022fc0831fb", + "proof": "eec3032e22299f9bee88ce6a61f41baf449efd4372a98ed428070c07d0ddfb64994d16b6f293e615b4a1fb5fd398b46e978dd5ff6ad614c9c39f536853cae61e", "timestamp": 0 }, { - "proof": "ea402e1d0096ad123a385e2f2059e6878084c6a2449c918f60393c884a3649ec2602b6b2df12426c852f1128360f1c42c74b819a8aa3a3907f7e587424297de2", + "proof": "9bc7e9b44ae1164b19ac424393b3aae41eaa70dc099f8a8bf04fd2293a96fa6cc21c0a3d64e1c54cb6396dd1f480484555cf9883c9f730e92237e87c7f22641a", "timestamp": 1700000000 }, { - "proof": "7b4e699cddafc80a40e39b11f518152e6918d0c811b3b0e3f0f2533fdafe0194c0c695dfb8b032a8c0ff645ea80d2d2d902c598fa178153879eb10939cf429ae", + "proof": "da6af2986b1127b12b6c2848aa3865489a702ddfeac3c0505765b72aba9bd721b559145e2befe6b59fa38afb3c087aa58cb0dfdbc73971299a1303594ebbca5f", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "3dacc48788a0ceda353bcf429c2f78a77984435b233afb0d5e2ab939f3f34f62" + "transport_pubkey": "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":4,\"verifying_share\":\"037887eeb910932a9c7973446335c1fabdb1911b0e833dd7abf944ba84f461724b\",\"proof_signature\":\"fea8949cc32d62a1567b4e4f921e9b01e1a91bb72ba4d2965d6098d94ffc36b29d9e6a49480b1a583ddd98b92658441ca509bd4bfc9eca66791c4b169bea2307\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", - "created_at": 1791465432, - "id": "49846311340fe83557a2b5c92ff1a0d223c13387debc1aadcd9e51696a2f3326", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6\",\"share_index\":4,\"verifying_share\":\"028ed3f1022a056bca7edbd0e3911ec6d932b8a00cb40765f45ce2ac4b307e1650\",\"proof_signature\":\"cabe4ca1222bb1cc976b4aa2658748a45025bcedc624dd2d4f6c95ae281e7eb23299ba6cc9440e3ad974c0fbf40ff1b32eadf67496ed1fec4db23fb4a05131cd\",\"timestamp\":1791467352,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791467351, + "id": "e1c38953ffe8482a90a747d3d3e60d7bf18cd8a57f3d7318cade62c5d43cdbad", "kind": 24242, - "pubkey": "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a", - "sig": "dc862b44488d38c8ab1afe6f913532e4985beeeb1b58886ac713028309a15974643e49c4b0ef86bdbee2cd5e26484d2f3b2ededca8ea48304b99e0a0ec70cae7", + "pubkey": "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43", + "sig": "6a86ede1372077a9c55b159bf01d0f61784df3da87925a609c17bf2ee4ae557d841db52da821bb3d774b3e0f8e61199de166fe43e459de05b27afa697e3b161f", "tags": [ [ "g", - "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" ], [ "t", @@ -1578,35 +1578,35 @@ ], [ "p", - "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" ], [ "p", - "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" ], [ "p", - "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" ], [ "p", - "edb073fdbd95319d1bd2520e55061c63464c587f34b6a18f2115d7b15977fc09" + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" ] ] }, "events": [ { "event": { - "content": "AmF1aXAH+eF56+FkxtjldHGX/OVkWGp8cdiIaSxi8MHoBA42sas2EulzOKR8n3xCiIgF+YLLSjB3SkKCK8QqbnY2uWHsjyvcOL93eki8kaFyXZ1T48uvwmfTKEdq3Nj//9HepTPO4joxlleHStmg6SFPaA5pqxXqpDlIWrH3MTPLDhUVpV9QZ+ezIGdbPKMZOYX63zjFFvakGaFfHVsYiRYlYGqD7HZWn4hcDCLXJuCv2iYVDRxDfPoTP6GVetVYT6Ie", - "created_at": 1791465433, - "id": "2070bc15119699341948f659b4ed20246a3c17f7edbd528391624433f1a8d135", + "content": "AjpswCmqaz7OVxUFmtR0PABD3yy4zZ4qpYwLlHjFjV+LbIwUKego6A5h30KmZJyfU8mYgmluZTIz8zzceAJM658J2D8Q9YXcAn0Yn7093wqFwrdEBPwjpZ+jOmyD5GLvRgSghg6DvvExC6uogY794bDqaf8y7l17nEZbV+e5BJHKnztGk0y4CV7S/dXixKiYHXdd6fLxE7S+U3BKQZGqCNZn9ZGRaYeZHdtqEEI/+QoJ1XAGxzTe4vvhqhgyxZJ7KCiz", + "created_at": 1791467349, + "id": "aea04282f72fa64f68eea619630d6c65c86f452094e70ab90eabdabfad6a6d0d", "kind": 24242, "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", - "sig": "9c9505b072b7d7b86381f5e096b5a0dd78444cef0ec66ed68cac4c8e93511de140e0c31d41d051714147ec398ed7c242c71d26e327bf9770f2ab284a4d8c3f8e", + "sig": "cb410a1c5f50bf1615fa88de6f73ba4f9e51d923d94496de82679046b3896db55a8b5d84ac227111095c9c4e475a32dc9d8768a1aa510c3ccc632d78c2a4b00e", "tags": [ [ "p", - "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" ], [ "t", @@ -1614,20 +1614,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" }, { "event": { - "content": "Aii5LtRgH98VsZ9WbxwBkUr7g9mwW0nKoB0MRs4+xNtYHDVdyRnFJEOUF7bo4D873HcZVC5v/hs6nS3bLKun1154du3lS6sKgimMNt22NKjCY40GkRD7Quj+fIVPNpKVyXw3SFF2tkkdFR16SKahsPh5Iq4ypeELxAGNkl00QZqItjHzT6JGe7bu1OXiLL93j9PlLa/lFHFcUsM4h2p05wH9RhmZQtdbpfEtPoUI2TP6CjJV/0akVPhnMku8tpiXqfDp", - "created_at": 1791465431, - "id": "459e5fbc8399514787c98647c5a510f527580de63a6161039f14823601164bff", + "content": "AlyK4Sb30XSLlp/WmO/E2DCzTEr/piAJejQWYttsOUYf4dbDXN1CopBrKfkLFyI4S/cffde0YPdL+LbtY6a6flE6AOzK81T7QMYrWDF/vW3M0ETgvxljAAr70dd3BGGaCXDqN+R3YLNdZ0VtOf9sUMLjJurimYrjwr1pRSSBNDl5YrWb26ITyoWScBeDiMmvvTODj+AEqh7bHggbX5bN8MrCRPH65F/oW1XtQtc06ILkHcJPLFU8l4bS/dp/obRl8jyW", + "created_at": 1791467348, + "id": "4a23764efd400f30cae1704abfba4a7dc16470217d49ea7f3945916eef35a79d", "kind": 24242, "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", - "sig": "de3fa141e7802cdbf05b939df834abe6bd15eb9282a0a74b88f320d63cb7f672c58b77c971a69f4b17c822a31bf1ad996eb0e5e4701fd5f19a277e735014cc32", + "sig": "e70f241a08385bc54a807fec1aba2d8b3cbf78b37604dedf46502ec35c69cbb1ede61b144263897ed99ab678c1a9a45f353211d1b43ea20ff7d31ad3d242b34f", "tags": [ [ "p", - "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" ], [ "t", @@ -1635,7 +1635,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"35ceda61da1f2dc866008332a61097b8c704ad1c003d74b17f37a2185c4c778f\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"d2f2e83674fc1a94792255d966aab54abd76e8eab15f27eca8584d40b60317b3\",\"timestamp\":1791467352}" } ], "index": 4, @@ -1643,109 +1643,109 @@ { "length": 1, "nonce": "1c69977ff38e31e388fba8e69046a7b65691c1c5461d23d7733217d758b0897c", - "payload": "Ahxpl3/zjjHjiPuo5pBGp7ZWkcHFRh0j13MyF9dYsIl87BU5jSha7upoJCY4m+4iMBo5QsdZkO8VWkMJ0UBqcQW7jKAxDsrUobwzRAlzGa1vQm3fykse4lVjVUrzFn7+9rU8" + "payload": "Ahxpl3/zjjHjiPuo5pBGp7ZWkcHFRh0j13MyF9dYsIl8+YFEMpmqMesthEM5/w37z8lvCZWQ88dMHc7DqDDgxdhXhEyIXvoaIm3NE6h7ZWa99UdHJRicuJzFMIrsdcBGiPSb" }, { "length": 16, "nonce": "5564d89263b681bb64b6a5ecb9b798b92c413444a406ed48da5de826663210c3", - "payload": "AlVk2JJjtoG7ZLal7Lm3mLksQTREpAbtSNpd6CZmMhDD7DYpbB4Z0+4qLR+WOJ2f9eQW7uBvnX0PxyaPEXHztXhQumliN4KadTw4p1oha4xYbiKSqhlRYASVoLxpdGV5PK20" + "payload": "AlVk2JJjtoG7ZLal7Lm3mLksQTREpAbtSNpd6CZmMhDD++qsJe08B86le7wlsCqqCdg36MQ5EfFwLLh8WqX4iiwAswXy6Sfy9yJ3XJ/HGu6N/d9SPBxAMO5wWlk1uBLyIv7L" }, { "length": 31, "nonce": "3e0b0ee5b9577179290dcc79dd5abcbf2d6aa6f8b02d5cc5aa5724b48fb9962c", - "payload": "Aj4LDuW5V3F5KQ3Med1avL8taqb4sC1cxapXJLSPuZYsKonUibnHTyLed1igZRWSXmq+jMhK0g4Tjv+lGtSNUQtGZe9tjUTAtTndiRzUODd0m0boeOg0jRLKpkUw6fc0S2K7" + "payload": "Aj4LDuW5V3F5KQ3Med1avL8taqb4sC1cxapXJLSPuZYs4WLXOHaAHlMOu9UQvRpFAK0KUN51/gv1GUome6mrSByqoeP9/W6Le7FtykdFJxpepqckqPv8CzWvHiACFTUqDBJO" }, { "length": 32, "nonce": "09d116af03e0a744e2df6cb2680546508d1242eb23de986df97c9c53e7a49e7f", - "payload": "AgnRFq8D4KdE4t9ssmgFRlCNEkLrI96Ybfl8nFPnpJ5/HJFJc1gLv4CgOomLLm2JKFd4GSIdUqSDEZUPLd3TgfViZF7m+2CWKh4co6TCVo9NMtVA28Y9D3V7883BMibwt25X" + "payload": "AgnRFq8D4KdE4t9ssmgFRlCNEkLrI96Ybfl8nFPnpJ5/jza/Sw061NDxo0sihV8CgZZDcAJ79kontIiU5+FaBXfRTAFR8R7LeX+feyP6EPtSqOQFfF9tpldUgFGMor1Nd0wZ" }, { "length": 33, "nonce": "91bf679d486db1a134bc0610bf5832e87773858ab80bbf87a63341321961e56f", - "payload": "ApG/Z51IbbGhNLwGEL9YMuh3c4WKuAu/h6YzQTIZYeVvFRy9ZN+fcheY5JffetKpNzkF0faK+50ghHPnOshU9MczEnpfb/IIbaTM4zIGkrtFWVqPVQHd7JqJ+xnXhBVpXVN8ZTKiGW4bsKk9o3F4j5d+F73nDo+bAanGFJZag0SRtIY=" + "payload": "ApG/Z51IbbGhNLwGEL9YMuh3c4WKuAu/h6YzQTIZYeVvcfu8dWTTYvlwm7/2w85LMdBGSrDN3qBg/sGMxv/Xxlik6BvLIJavvmxVFKPBvS008OCrqdy598K+dSFX6Lrs3i1exO8/KcvrvfGmEaQ0VVfFrMLqELHrRysmfhe1rSxB5GQ=" }, { "length": 64, "nonce": "52e3346af81d9e4c18765ae23c11cb017fe02a6e9f51d5dc9f21211ef7731aae", - "payload": "AlLjNGr4HZ5MGHZa4jwRywF/4Cpun1HV3J8hIR73cxqulNfcl1f1O26LpC+G0AY3+pfNfLrHlkiVJlqX9NpllRDGYIUgpspXNikNAzi4Phj3w7RKz0dOWgowlnrkqnaYa7+hpfmvEwgUvKOm8uXN7/BMzri0POyUv7RoT0DCg+lmaC4=" + "payload": "AlLjNGr4HZ5MGHZa4jwRywF/4Cpun1HV3J8hIR73cxqu1AwF6C5xtXbO8VKinCShpl05KhUSklgxb6GGM87vZXwtHxyoLI1PQW3CVMfGqTC4CWyQ02D0VaP6IqK338hIT632eqazN7SXSAUk/WdtMEcLul9SFR6saaBB9v4YQ5iSSKQ=" }, { "length": 65, "nonce": "4243702f2b82f5a460b2c73737d0452cf3d040097bc4af6a53a7474e0c3cf7e8", - "payload": "AkJDcC8rgvWkYLLHNzfQRSzz0EAJe8SvalOnR04MPPfoIHIdKP3KUNnc450J96gCsj+6kV5D3RQAgHl6a8Zg3a4MYpWH6cp1Wp8mxXCP99JrxP8HbOhwf1jfhzrhPgFxt8V3CcnLKeomiRLG8iyc82c8NXsuulE66ZaJSd3gk2QvE95lr4T0rtuTIyLW3KKIwtEqyWq+6rVHojbzGx7sQ08QhQ==" + "payload": "AkJDcC8rgvWkYLLHNzfQRSzz0EAJe8SvalOnR04MPPfo5dTqcfnkPSjlNZ+GPG6hVMgp04q9oOwqx98t8+NjFxM97oGb+F8taiY+MgTvEb+z6Jqf3/Q8tGdKyH4L0YixITlUf5EI5vePLkLwnv+WTpemc7VuUfgidxH9dUTWEQTYxtL6EQ0gjI4tEjoXSRbswbXJ9PE31vcI+svysWa8TRV5Sg==" }, { "length": 255, "nonce": "276eaf1baf6f4b911a4e857d04fe411859a6518d6d5e86011f095426458cde52", - "payload": "Aidurxuvb0uRGk6FfQT+QRhZplGNbV6GAR8JVCZFjN5SxSZZh9KLC1ky3zvpeX5KIvT2DEfZxGI+uHTqXtAXEHmqPgzB0/fAhDEVN2VJpic+HHsr8YETikigfvf80qp6nUfI/voF9+AS6sozD6Q6au0r1cptf0zaodPBFDH8aibFwlAJIo4pXVa3MhfPithcEtfTfZutRGZj8j+TWzTUBvCQ0jfLbKDMoM2mitNJ3B2pxIrsWqxsz98OUXyrpGlYaVdpzps36ZfNGqSyQMSUL+jibVVlHU7sLRV8TrgkzQjYlioQ4T88p1cwl2XQuRmPZxGK+uZwUPjC8x6XP1Hd28G1Mqj7SG0gxUurHUwO4L9RxomeocCxw+exZBsEheraTkCdVMSDq/kNdCtbWDZBSH7qL5f7JRuioyxtFiV3aodow4k=" + "payload": "Aidurxuvb0uRGk6FfQT+QRhZplGNbV6GAR8JVCZFjN5SEXcmfAX0sP0LP0JTDNw0dNPC7Rt6azC25EG75nFyhbhFKRPh7PQluJMa49nWJLvKEv92AmIc0sucQisAp9Ge7dyya1AY9yOBRaL5BKn4GCuW4pGm38XzKKOlFY1DKE4kg2vtFDGHknSYlAYrVBW6OS4uRXo4aee8Z4mVGwzO6A3DEMFV1HfNImWGK4QHcwwFLhtKO20j2s13bqV4jaAS6S0DdEY5mqMLHKF77j4FBHZeG//Z5Lgzl7QNMOoQ1bwfHvBeat+nZJdT6SxmwKarJSpelo2rcR761X3poX2NS/JBSXiAZqgYDuMB6/7UCdcYIHBJAr+dVT/rBs9K7d4ue3HKQT171USmslyod7d7iA6XC5QCrikZv+WIi5kN0LTUeWI=" }, { "length": 256, "nonce": "da9ef386af6f248191670a3587581c0dd45fe1708b38ae866873c1bf3be336ab", - "payload": "Atqe84avbySBkWcKNYdYHA3UX+Fwiziuhmhzwb874zarwoes+px6I4pF8sPw3NpPxk9Wl/e2i2EKKC/sArCjjIqzd236n6TPrH3DdHWF1sapQv/PHvOWgCgnMIrePKBDl9aeucMnF4vyB9fqmJi7cPpe5mw3ssdtd4jXeEERlKO84yDWMjsE7mvRmfENP9M+Y9uSLTdefdzT+8e4IwZZSUlN+J94ejTsDP5h4ZoedAT37MQqbyBlcQDXzP1Tdee/cnLMN2FNTwRxXG5bpD34nraVdYVmZzjFfhzsZzfJsa+x2Nga2fkcRKxE1veVSVTntGOmF68bZxh7UytSjBhoEwwQUGQY5B8FJzfL3Z2w0qdpmYhlGHTO6vpvvfSWjerosKx/BJ5oYdzwpVWSRVpLIVI3esBs8+GydNWnqfcIDY7DEUY=" + "payload": "Atqe84avbySBkWcKNYdYHA3UX+Fwiziuhmhzwb874zarjk7ANV4fdlWE+Wb9w7ytqTW3mD8/RDOIp7Cdnc+nkinF9nsxRnpc00+TYCB/a5AqPMkv4FYU9g2eg5tmDvXbBWCVVkg5PidgBb2omM0hIafsjyrz0tptw1VlfBGYnACgEqzJZBgqdiX/N1FfR5ZT7t9l9B+Kx6nuWMoGizXQkuL2svXo3+nt0K3F+bblEmfIAtRN/dKY6f8lvTgGwBKN+mJn8XGZ0M+9FqIi7kGkKk9AS1IZchjbXlrN5ZHZcmh8vL/CuVAmasvtWwRiGX14sNSxNmTM8qbhtTd1Mujh5gTcgn7XyHoU+cSgrNYmfxu395kBoiPVHOfQiEvcdhSaFPXWJgYJxyzVS/Lr0bC6fN6/otLMfSY0BCDlsdv0ks1j+8Q=" }, { "length": 257, "nonce": "3e3cebd5a65bfea511d4f74daf272e34d2c90d1592d0fe762db7b84c1c2a891d", - "payload": "Aj4869WmW/6lEdT3Ta8nLjTSyQ0VktD+di23uEwcKokdC/BhkeAbpCMI1/8YlWCWJyJFXZtykwKvnYm+06OHGRvh1M/OcwOdqsVFietJzsPuwOxmpE6wAGn32E5S/2nibTjhMRohZo7Ml8WbyIy9HQRr6q7faIvCRe8OPvGYlxAkLa7oIq7yJJrr5ExAP0dtdkCLKzmwNchlSD1m/1L849HtFNPUKOeRbKGmToTKBQ1HCZPgPKzJuU5p95TVozUeY7IzyFxPhJE8BgZJapGeX45bkpieXDqnqluf0NJgvhH2fxbk9csnnQlT99Bg4QpO2nlwOkiwryamGhyfHi3S8Uh446ylLZrBJHKjbriVxHx6MGYEXo3b/NMdguXI373Or2SW4ePPmO+hcuvsw1BryIcdo+brJLChychmuKjFZB44mu9f17ZfEDo2caYgVn+cxGB1x1P8GBPsSzsGHIUDI2Z1MxXazJLq3ateyazjnvw/aaDo0uXBTZ5os6QazEgnxJDv" + "payload": "Aj4869WmW/6lEdT3Ta8nLjTSyQ0VktD+di23uEwcKokdLQBvzkgpqNpx9xB7fWEiIgj2lN8BgGk5P5ety1HKT9JlJWU+ppNiXWzTAH/yVjT95ioThZIX1n912RJSPxrYGAmEPGyyjD1YhAVnfZhC4zO1ND72jlSjkSFx1c7UTz9+cCRnzTeTRSJhWsoGVdU7TvgBV0NGIE0VXpHiv2lWsxve4OW9YMlx2wScuzmB66bYWfpkl7sgTQWOKvO+jtUg7lLJcRK7dCESoJVWDrzsIBK3rv+VqjhQz9oEj1TRhZ0eJ1ni6Axxx+uJsVXiq0FFpl1nfKSNaQx/88FkzsLaS0uXdfqDxgm+WXqEkid3YPxC/FNaiVcgl/0WWdiMCvWu3qkhFG+e2xuxs7DgZEOc+rKRBcWxcVM3xXkPQGKwASJOsc8AeLePzIV2PADTBpgqMlR+7UNsbVdL8YrwnFqLbs4Zyxuyy9R+Gj7UiY7xaxpLGlPWGFsWN6zCGtSHlmzUoNBG" }, { "length": 300, "nonce": "40ff8c18d0f652b4df34d16b6dbdaba5508f6a9b8e50fbd79fc8290249a6361f", - "payload": "AkD/jBjQ9lK03zTRa229q6VQj2qbjlD715/IKQJJpjYfBlTkeJwH/ImCKf8SoxXRrqeyG8lIUO3jm6szDP98fQoz/jY4D3tsAwTH72/WgjteI1ONPHrX2X4h/WK+x7rv4seF7AsbjP3ZZvWpK1kjuoNO8hKjeDp2Kj+Xy6X8qYOT29rzzAS729CIhgHE+YYs4UZF9DV6xfpW87EQkmfFGOD5TuQnE4h742cKmZEJ3MChTEZ0Ht76dI4zjSEElBNqcyLgfSjN+L2w8q/2h6GNt8FptQcql1hnIhnatZo2DA0EA8CQYEn31pR6D99e549Us4GnuvpdMkvySMuKfLw8mFyFMW7VB3s0qCDHlwBk6W8SIm79UgpflKKmxtb5BwacoO/yokOd01OhAKSuu5vQeGmIa87kD8TDvWvPprbr1Zw9hwkBrdzPyvIERGreuqyLRD2I2An+fTP4dD7ORzc2LnxgygJdjBw1+XXpVz2WoOJxhK7CBFow80yJNlsbMD8nI83Y" + "payload": "AkD/jBjQ9lK03zTRa229q6VQj2qbjlD715/IKQJJpjYflMw1CPFxk5kYVUQRJ7UNEvku3sykO8HmB951UmeHaeEuNLoDxz87X2MSec900uhn3GV7imlS0zIIXidhp46k+BxjtIgyHkKat+HdTnBhb8SSrS3uvTmNbPoPayY/NdNSS3HuHsOULlYdGA+OfcxSVKIS9XLLpIUQUcrHUu1C/jvZu89cyYrw8ydvcrRTxvdUX6OT34wVGnh2FcGYF+snSGPj+zOetHJcvHPd4YmQuPBpmZkDe6Ig4zennCPttEgDh+RlVEvacbTXH86QtQZeprMMJsdVFtjBcH0UXwg3vgM5vLkuGkPr4DpAzgdtfSnX1Ht+iTpfBYn/XrS7mMEr6Po4K87SyyVmRgFyzSIrKxc3e2F+juSVIxE33LkmFOQH8ZVEmGaTOaWbqNtACo+HRhLqmoYu2lalg6IsjBbadiIAwsNYm1HkFTn2o8DtwakZig87tKmKjDX07IHUeKnStTuR" }, { "length": 1000, "nonce": "0e2344313f168f53586fb4198a97093a4ff43ee06386ffcecda1cfd06c1293b9", - "payload": "Ag4jRDE/Fo9TWG+0GYqXCTpP9D7gY4b/zs2hz9BsEpO5KdUntu0cXNJD/sPGbJjH/bMKpDww0PxihBm7CMHWPZpnnh3zX2Ptu3QNwQF3qhgBkNTu2+IXbV2jQausAUthLBzLO+zAP7hZ7MRfjFUlf6oKRe9jlkQ9mMm9k8BAie+48tq0wbSYyXTBIyuDhi5I1/mMzjI109ywksRVxA1iW+1+5F6niyp7ZM3mkAyBnGaIWNBD2AhtBrlGDTtXHCeIgMGWvRHgcqf1bCJQrMgZq0OROefELBqqq4IisTQG4KyVBhemZDuaFhPYpeVhONcI+DyRf28YGmEIC0AAvISXCAwhlEg/Nk0mu3snNpcK2XaKKSx+JqVOTI+3RR7wemiM+4rhGpWIaOr82+deO/+zEfPa56z2JSvyzWCjxFb3zuayzuKRTKszvl6yU9+Bj1JKVAwhB5hWrHbNxHXxeSa97ImG47lFw8Y6yrszqJIe+a3j63LpnVlZnBBYtVZlWvrB4aSyI6LTf+EA2GnI8jF0vPGqDQY67qPgj9wjVVZ+ya33XzpLfHRplgAjLHQPalAo9/2CuiutKGdalcSwPoISKaTOrnsLckkyPJIsAzaMA2ozXMCExTlvZrg+u0fuQoYvwOLk936PzI/HNFoeqQdwOuNxgbhGUTn9db7vxlkk8R6yjHauJR0gxaVgRbRucfVDcqlKN4iozBthlUeKTn/lgm3avQ/OBiH/WElkICjWYKPUc5fb9MnjmiwhWo2eH/hzwSR7uaCS81JaLTAPrExy4tE5xgU523mxUvl2CTvcPgb7hDfVzWKOXWh8Hd/mvLsKFq+yj8DA6sB2eXvktCYuWywhOC/SWjwmrBoq1rgDYxzzZnmgQ6QzWQvE2XkfKZWZIiq+r2xndbfTnrjcG2LNxdkCd0s3+x528opwoIvxC/lO/UBpPFPFBce8yJhqRGxxWVoy4rS1Q4asMJQKYrw1yzKY2AUC/hT2RwPd4bPFfygaQIL0wnwIU9wMwlVKKlkaV0SHmCJcXiPANlhtxmu0OoUk0e5OfPn1RGBM4Dkse8JAvdoaguEVtasDPJ1Sg/lZ4lNnGANZ8toIyHKLpDFRoYQ0DsVcmVkI7A1XbmCvXd8/E50grov0cWxJECUNjQIOKkh7SkNgefodrNy/ecRqw+WTO5EHImLnWzq9G4mUeikyGztGdYRNgFlpIDgIWNBxjFq0nReb1LNnYtJIqpiJ9VQnt6XMTgv9HUdDsVuioeqr8DwZZjcgcPNsHzzj58KA/dfAekV7PN6d0qGukJie3gPIOJWx84ODG557VrYKFE42RRfF5H/uP1BgH3dyvLwKCyfg81QsEkCwi9kHomT2HdQ2qqkgxnU9pde4UuhUObrE8tZraO/HxNGOwO0jZV5GpOqqxYoqzg3+nVuttkfbbUgG19JwFnOMw1GoYJk1qYVj7go=" + "payload": "Ag4jRDE/Fo9TWG+0GYqXCTpP9D7gY4b/zs2hz9BsEpO5UWhOg+LJDMQs2WNFIf7RVV172rEyRdunh0BBYtfZhMO/cBBkEVP9FeIOSpkyPS5rMJ/KsOTc6iFGVwTNfuQ5jl8pVTN5F7+Gx6OF810xH7LtqT22u8LVt6+bijFSvq7X0R9s5t53wOTk8ju6xtTVX/oU50gLdUti+Rfcy6LHDxKrMvTp2LAv8+j0EYjYzhEct3Lp/FJAWBRjg0F12iBGAv7qS/wGr7QIPJV/pm6QjWpmARqe932Y+JrDbal0HrPdpbNcL7ZPqfdaj0J4QAEzfMqtKY+S25TpiRm8bQqMPwBgtI6DTetx4rHs2OjZdd0d3VB9AOzEM3sElCcDJ9/zt3fMXLaYTP1ogSRSKREe2ciFMAYhLqTvI6S+Ir8RZ25j7h5XtvwAfVdEx1mOnnn1awtpqHBtNu69mTUoZ/4z1LGwZALlQGQyD42Siu0kaf5bJ0bFoIT8FfGlGSGLEua68bKpkWD9IkqBDt7vgA5cR4v0gFpLqqup9MO17bSjh9Y1jUYbob8qvD6tmMXKsf1DXpVAAk4fVO/wfGiXbPtlMUQCpQatSbDPuSD+e04GCRTLfeALnQ/LMEC0xHfjmtge+4MVbt0/zmZ7m45F7N8eR24PzdO2Mf+tPyjp+OOtsOfI5COcnoajY/IQqiTVxK8HG6w9d8BvG7gtJJ7eP5426SXvz1J/4PaHdznmoOYC/rDfaxGmh7m1Ec3RH234+aZBTG8ODQ7H2J6oi9mIo7fb+5hqgco6kW72383y8qdfD4qavTFs+D74EMpjz5kunvfWNZ5Z0MUlAhxaBDefKuSJGtDT84CMNipdOOVRXB06vrBQytTbCtzYMGTqBjZ4/js3NCOPelQYv1XibxZ6vQwzEb9cq8PUUuLBt6FkGvc4kLUNYCW07wZNt8GdStnehBLJL7GFFkSWChORSEA0kQR7RNlEPwO7U6YAjqjTDsSEQHEHyC833Em8b/uuInk3GxCB1ePgoAwbtas7mlSX/Oyn7pEcvsZNpOcGgzHP7pJ/uicZmeaWAaGtpLr+ETcYDxuVI3PWeENCnBJu6JyM8fACUYZ6eXjvsp+1BKy86elkyEA+pekec88fckkKRSirX0Qg7bztzBdmCWq3jB/Wk0KAXM79kS6WXfEWaGrgyOlnyu/F+OGw/vjuRvStGaO1nNTxzrg4f8MatB5VSCRx5xx3msvKPosZQwCNr2SZcIokaQ/XIGkZXQnHrORY0Du7m1SqdHd1/VWcLVxQBOlbObuJpTwlFGWtm2FuDzuuEMRWQDnUSIW4LH01IrRDHqCL6dWGdU4U3Ga5GWUi6HzUbYZ2FbK6trmsUtiEQrOXaDcfbxJ7sgVwbZjRXCGMMaU/RnNwvm6LgnZjsaSZRGz4x7xW71CkKh1Y5oVvOqwbHbNlymQaiP4=" }, { "length": 4096, "nonce": "5ba452ecc994c974cd71245debc1c5a9bb6d8c7141a87ab1d7244fa8c6d0ca88", - "payload_sha256": "952308e3aa383c613c0df2842e3fd579b0a32aaece24a3728911bbca22a74e1d" + "payload_sha256": "4e8245c343d0987e57e476e6a5966b718d644df5dffd4b851b124da0809c3f99" }, { "length": 16385, "nonce": "09262a342ed3e1b304aea5a803ed4d27fb5c383ed31323b218348d759f263809", - "payload_sha256": "137397dd86100782052af73b72ce18a7cfcca12afb7913734ce99acd6da61658" + "payload_sha256": "164f34f914a478d1ff2a2ff15b5edb06b0beb2f8f321992327eeb04b5eee531b" }, { "length": 65408, "nonce": "336a3fde9e6354b33ff14db56f59c5357fac6e96374f7656afc1822f3ed786c4", - "payload_sha256": "941c25bb022da7e398edb80cbd213f00b8506c90a54d0cf87e4c87f865fad73e" + "payload_sha256": "205fc34e1e0b3f363ae5a8975226ceee3e088eb585fb9a47eb640b62ee96a054" } ], "peer_pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", "peer_secret": "2875faf11d95de0042df207ea55ae62a67664010a3f8b406b1b548028d5d574e", "proofs": [ { - "proof": "937c4c0f6ca0934ea0ff562939693d016f2ca24a8a667dcef3adfbe7b4abbb23b567886bef0342fec6d60b9909681fd6cf5526b4e499a4d4349057efd3998424", + "proof": "7bbbe31d6ffc4824a79c8d90a4cff0c43cee04733bf17842516b98837f866d11fa8da08b0638e9ff10b75aef1f6b0a56e2f0a1e7d958e8dc95cecafea447b141", "timestamp": 0 }, { - "proof": "8678c8762e78c7d54d479ead73beea5d69b80a683b86e0f910d6ef9ba766b5b542448a1167d6c6221a0775092cd1f6f347953c6e00bd96a62ab170bc1e411651", + "proof": "f447a28037f890063cf70e6ad7f7da0a3792c1fdc5c72d5cb0d5e9d8d356c96f21b72bf117813e2a2fb8dabb36414a814529945c8d2cb506b1fc215010febd04", "timestamp": 1700000000 }, { - "proof": "e9932154c0fce45c9fb258cf6b1d17ffcb082238736afaabfcc8ab9074496c97db08c9de94d18bfa534004f236047a1d85bbc7f8001216adcc6d84fd8a1375cb", + "proof": "ae0d455a158348eabd5bfa9123d64d7044874ef4784b0498ffeb2b222bfeb6cdafaed598c12d49ebf2273bfdcb661e2f7217ab5383fd48fc7903da76f3642017", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "8e1ef17547747cb1f7cc4d4db2a2ab7677b07e6e4795807fd5f182aa4ca8d80a" + "transport_pubkey": "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" }, { "announce": { - "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d\",\"share_index\":5,\"verifying_share\":\"020f00ab70660c72cb08df914e45202c59819af901044bb30d882b969a1ca325a4\",\"proof_signature\":\"d5eae859ea5cc22715c59080a2aa8b493652b5f917e64dd64f03da615caf9dd9e971b992843475b83749581a8256794715f12040dfb7caadf6863b7d5ce6f91c\",\"timestamp\":1791465434,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", - "created_at": 1791465431, - "id": "6d25ef8c7882362c6bf94cdb60dbc8352b0e6d4eb1b7d29b1cb63fa9b9c9e1d2", + "content": "{\"type\":\"announce\",\"version\":2,\"group_pubkey\":\"72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6\",\"share_index\":5,\"verifying_share\":\"03f4d941d419d4de23a1dcdc76431548e0c694b90f4d5bf13a41e0aae0b35270cf\",\"proof_signature\":\"c0b9f25dc1ebad93490728dc7cb4a5f96e2d50a81fdd328ee3880ed333c165d95abc569d37e62a959e8243bdb8af05f6113f560761eff6dd5b35f10cd733a4d1\",\"timestamp\":1791467352,\"capabilities\":[\"sign\",\"taproot-tweak\"],\"name\":\"kfp-vectors-2\"}", + "created_at": 1791467352, + "id": "226ba138eb9cee8eea128ec3d728de9dd6fdcb516f0943194d73de5b319c36de", "kind": 24242, - "pubkey": "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f", - "sig": "5dd778f39c78326d3464beacae7e5c4d0fc72494481368e2969b1ff2dde440b8765212a51f04d8f5c75e15e9619f59047ac42b02abb5672499dd85a5d7db8be1", + "pubkey": "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1", + "sig": "13d566b0e8ce386f49c301b01b31296bc8325a8d19b39e47792bf8a084842d9e268e2b7fe913a63d43ca7e9cecc28c67db04ffac0bd44993cc9b1b383dd9237c", "tags": [ [ "g", - "487c9dd529ff1e30e7f75a43fc210b3abe959f459968add36188236f47a8808d" + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" ], [ "t", @@ -1753,35 +1753,35 @@ ], [ "p", - "59a27f4e6001564cd8b6fe49f57766ddc651a3206842236ba85595e483159577" + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" ], [ "p", - "7dbb8812ed63e13c0b74382bf6d7676b08da02a534f85fbce071e7710c6a37bf" + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" ], [ "p", - "56940bab006fd7ef38f950d6c79f6563a3327b2281ca6d281f4510d105cb364e" + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" ], [ "p", - "63effdc924dff4643e79fca0d3af099970be2fd600599df95ac0a023e31e0e23" + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" ] ] }, "events": [ { "event": { - "content": "Ar/vFPUjMyrTA8kdq9eXHOx3C3e5p5Mo9IJIO1SJmqgGSJHx13bchaLrChTTq57hib1fANN5gnO+3dJCUIgD7HJflmQpK9lt4ZFPJcegCUMg6wZ43rmIE5bd88Oxu8U0ugb+PeyCdz+yGhE6eHnue/+1xWJQ2xAa9R2xGEj43s1BnJspfNzZjIPpF7GRr35o/Gyz2JP4Q0WUCZ4BnnIqsd2qP7GqNXMe/dlfDbxom1VtsgwIMh/sCkZbk16Af/o6aoVR", - "created_at": 1791465434, - "id": "5eeb1c469f7373c951015d8c1252ae0100113c6ee2cd114da9777804dc85f4ef", + "content": "AmBdKFELkPoqwkzLKVcHTVt0i1rHPWDMBYroqNYu+RVX4VLLcPUUI/+8kG+YudWhxLi+GuPQuor2w+ZHGlwvgg9qMeZtg2+XfQqb5uQcl9hg/5m6EIsIBTmx/uaI6kmoZeXi189VuqZlQIlIROxomxxVCmwjZ6RnWDf933IpHvVwFZJrLLmBCJhSwP4QNGWfRf52cieAvzwrXL/47uTvq1+mXbJj2DQNCe4hV0YN49r0u0oGtwrZy0dwmspIbENWq276", + "created_at": 1791467348, + "id": "85c9c17419152004b9f8fd0cf23b3ae8960662e1bbfc51ad2e25f0896d505f16", "kind": 24242, "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", - "sig": "37ef18555e3ee36980e80d139666283308adbc683e5512fe5447699f9e99dee81b10218645570510bb0c48897ceb296dd7cca5ec5d57b9cbde3022de6de3e75f", + "sig": "c1f9475f94cefdd356e9454e9be1c76f1f6f40c241fd3c16d207d3464a484f299ea38e86ab0b705df076eb58154ece0887cdc623a308e18b9d733e8a29b999f4", "tags": [ [ "p", - "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" ], [ "t", @@ -1789,20 +1789,20 @@ ] ] }, - "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" }, { "event": { - "content": "AruFgbQo6N3kIESe3YWR7UEDDDdqeZk0nyrtsW/X5uhG79DaE+e0NNtVDPQtSAlSku8fGFIu64QHFnIpZzP6dapcrWOx3AIYuIE7IY5yaNAdaXyBorYw42HgKUNeCsMscynPu/O2rcMBJGkk2MuYy1zUCH6fRW7osG6X54lsZ2a5RgKZxGe6EU9SPNXWuAqz0wQho6fgEoAOwouYAvsR48KUUCwLMVKLH9xB4CkqHTRSCC5GpEFbW4JMRoS8xnyQgkJL", - "created_at": 1791465432, - "id": "6d213f80da9dcff6e16fe295ce8e0f124a7b51e57c1c713a1f4ce7fd19ce8d27", + "content": "Ao9jWX92sTB+QIRu1gm8pYdir99jEgBnnNzfJl9IKZ+JlrYpBJhWA+CeXssIc51tu1H4ZGMy0eeEr6zuiXDu9N7+Z9oDyPFzBODFszWT0mhvJjIlNMCxyF5J9DMLafkT0H6ypBXffb5l4WPjZsMNwFJQy2orvRlHLpWxD1yuxbEnWCuOHaUWCfQymutyBDolttmGEhWrYqc125yuCxy0vTQBK59PpEZg0hLAkSVgxWqnkBJ27uBMu6nu78arEuDAlyql", + "created_at": 1791467349, + "id": "a94c7b867f15406e95d8105d69fc9470267af890e3dcd0d4601139923fdc64e7", "kind": 24242, "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", - "sig": "e1ec74d64ad8b0c3b99c5d39463352439132e33ce18f04cd97a6310621a566e744cd4de8e95e45908502f6d2a80a8fb760775a3e05d752574413bef09aefca27", + "sig": "65343f0783d8a44857fb6d8c668380547b86ece71d3ac1747d9638b71b013b5481bae2523a869b4fb64f240a2065d86f4ad038b8e06f91301e986354fb250ae3", "tags": [ [ "p", - "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" ], [ "t", @@ -1810,7 +1810,7 @@ ] ] }, - "plaintext": "{\"type\":\"ping\",\"challenge\":\"c43ba0789f984f694c603c1e06c46420f5aa892f491c14230ff4293c07bc8259\",\"timestamp\":1791465434}" + "plaintext": "{\"type\":\"ping\",\"challenge\":\"ff7f8e49ae2528f9692b635665ab3cec76b2262fe05c853b677d2fbe8e3fc85f\",\"timestamp\":1791467352}" } ], "index": 5, @@ -1818,96 +1818,96 @@ { "length": 1, "nonce": "3c7ac117cc2377f234f529e9cd6ef74fab4743020ef5c03422382f234677a660", - "payload": "Ajx6wRfMI3fyNPUp6c1u90+rR0MCDvXANCI4LyNGd6ZgM8rcljYTIfeqfWGgfMVZ7b33qvD24pvpnat0U3UfFN4WyMExlUqpdUoEyQOthMO76+t08g3JKlAfBLoJpdsuSHOm" + "payload": "Ajx6wRfMI3fyNPUp6c1u90+rR0MCDvXANCI4LyNGd6ZgkOsgDV9hZbao3fwqzM71WmeRNBd0T9lNM8G3a4CwXfu98AfZ6Ljyb+6tQjhAiR+rbVoMfTG6oVWawrOT0ovM/8lH" }, { "length": 16, "nonce": "ecb19febaae9cc3585efabbef1fa716420cd1f454d0dfa8ab2820fcb7f447860", - "payload": "Auyxn+uq6cw1he+rvvH6cWQgzR9FTQ36irKCD8t/RHhgOj38APJOOnXMsz02Kq4q2/bNZHw9BvEDx+6+exOC0Irf3pIfc3+Jh7ezMvy/mkZoHhk4BevET9u67vNNBC8t2TEE" + "payload": "Auyxn+uq6cw1he+rvvH6cWQgzR9FTQ36irKCD8t/RHhgz0mQRnWeche3+oVIfyKx1JqY9YRDWtjpivbn6uDaeeb9K9UpWTcio7m36mAPsY8ze9HEKITURX/7SbZX4wlXMuA4" }, { "length": 31, "nonce": "a652aa09714288e2fcc7934abbb7fa2d4dff8c902757696c3962b299bcc2dbb9", - "payload": "AqZSqglxQoji/MeTSru3+i1N/4yQJ1dpbDlispm8wtu58CSWjvy/7vTP/ybWTFVWHhDjVDlVsd2FCnU2yo3CmHv09RH7SX/n2PoVKHGzMm+u4XioXIY6KzxHUwuwDWRlZO+B" + "payload": "AqZSqglxQoji/MeTSru3+i1N/4yQJ1dpbDlispm8wtu5urm3YZOxXsVgOrZjGBhoyPKmGBaknaLB6Ze3t5G4iLOCqh+BbRoczLcpq2TmLIHemty25wwVYSdG41vzziBmLLXP" }, { "length": 32, "nonce": "9b21df32e4cd885166a4300ea670dcab9246bfae9a21ef1191820d6a41ed3836", - "payload": "Apsh3zLkzYhRZqQwDqZw3KuSRr+umiHvEZGCDWpB7Tg24o7Gflt+aBZcrh4Ek9lk3Z4+IQ6vFjsfCEDTsgFbC/drVaOzWMqBBKdtdHsx25hWI5pNfgiAEeosysF8VMHEDBT/" + "payload": "Apsh3zLkzYhRZqQwDqZw3KuSRr+umiHvEZGCDWpB7Tg2Yj2QOKvuM8w+NVgJ1Fg75phVBhH/ayCBv2AXJETdN5YnzpDMp+LnrVzcOe4O8Mhd8a1foGWPS/m9h7E2xQ0QBxYP" }, { "length": 33, "nonce": "f2b8a78b996aaf89aac6ca058e928da7fb9bf74d41230c321cc49e577b036242", - "payload": "AvK4p4uZaq+JqsbKBY6Sjaf7m/dNQSMMMhzEnld7A2JCsYGX7lOiZs8GXs88K1EvR/2+lxULgz4wxWuxd3Gp/3y7F+I2ywOq5KEBQTH7vMmTDFG3+OM88KJxyrLrau4C9ARSGrfepIolmaoEgwN1XRbpMPLf2OAMwPuan7SsgQpRed8=" + "payload": "AvK4p4uZaq+JqsbKBY6Sjaf7m/dNQSMMMhzEnld7A2JCLkZujn9v59wmK696HfHP26vXvHKkNCQBXDNbXUW/tC79MPXavVCvURjtWSFqSKcqpOdiKgQk9bhteCgoNAVo0WtqH8JgsYuS1p7ssRTfTcJ47WJbWG32FCCJs/01XrczoPw=" }, { "length": 64, "nonce": "67f6b822b700f7a8de753c33fec9a9d5f5fc726591909464ad200a87ea3ef9fa", - "payload": "Amf2uCK3APeo3nU8M/7JqdX1/HJlkZCUZK0gCofqPvn6oQ79EdZYXG0E0T3f1GwmjgcooiBl/0QuVqvQ4nNr0dqWBbKYUGuv2WWb8zPdFN+QIMCLpIolfZPoc8tX7l6PQJdtTLVMB3fxhhL2MkHwF9eQur3kE/dELzG8DY6vZrNRtAw=" + "payload": "Amf2uCK3APeo3nU8M/7JqdX1/HJlkZCUZK0gCofqPvn6zA3hLLC2QpYM5XNnrPsYSPB1aH2Y3al3XTWdOWV1queUlFKC0VkbkopZJMYux4SVGN24Hx+SUYQAeLMZLsEiiCf0pFukPE9YraLf5sz9ixlCWCOE4B84knimaJGzb/L0KTI=" }, { "length": 65, "nonce": "2ea8e9e38e9ff0dfc3e8f0ec568071d6fc78202ee9df257cbb3920f2e2f4e01c", - "payload": "Ai6o6eOOn/Dfw+jw7FaAcdb8eCAu6d8lfLs5IPLi9OAcOKIu4Z5EVNTsYly0xIw/IMnjk0w1E264S/jX3kEh3P5mp/Z4Cmhz+WZRLhV2bOktYS9ukYG7uaoYyePy2NOuz5ZX9KMtL7qK2x/3fxeoQ5RXF5v0ICUPOVWPC53K8VGw7qFdUwV4Cy9DpoH3InmQaYo7snvGHmJu110IaLyzJgiHAw==" + "payload": "Ai6o6eOOn/Dfw+jw7FaAcdb8eCAu6d8lfLs5IPLi9OAc8aKoda563rG34fTchHM7hzDUwkVHcjyvpQtjoW8aQRcDiF2dVXYWsGnn7oHgEDiqr+JVCUZb81nk6sWE5+KW6E2ZqC6Pb8Y+4yPmcIjCTR+OZlcaFCqVF+pPAux4oQIg4bvIapDWLNbpIavC/+88UM8a21y8ULKzDL4GfrfY/CfKDg==" }, { "length": 255, "nonce": "b36b8dc28587782b60f0ee4be993a630461f20ea9c516ddc45f1e68af9c8fd27", - "payload": "ArNrjcKFh3grYPDuS+mTpjBGHyDqnFFt3EXx5or5yP0nFcIzuRupTyznf9Ox/G3lRaXJcV5/bZi8AtJ2dmFUoCglcZPvBpvWjjAZo9jlN6rD75a3z5x7GuMoDzLK2s4QEYmo2k5Coi+gUvD4k8aAjF57rPnvu3acOdINXNbKCFMcPILMdbkh3KOfQsyHBE3lGWdGavojMUDaJURzXxQvJMzrMOoRzM7pPVc3q8BQ4O7WTkUNzyddGUj9hQlCuXN9yMlNWsUZZHtUMfLaXmzlVCaem+ZslGu8v9vOfQGTt4VKgmJjcKfNFN1V/CnhQGzGsPO6hdVy5vyEwRWsyCqSuu9MPY6W4H53IYyzUVS2dJ4XqQ8uMJAe2KJap2bzs4Jml9tG9vE/JMllJDHLsRoAcMzGdXrIXW1PoUMWu6Jk7fLR+0c=" + "payload": "ArNrjcKFh3grYPDuS+mTpjBGHyDqnFFt3EXx5or5yP0nDOZL2SWIJEDbxvtsAA8Rc92U1EnGo1l9LV8qTsbQCAdZ1DATG50/j/N+AEzpCQ09Sz84Tgxi0Lo5M9zENEcUifgh1NEi6zAvy7XyTM4kucBgTHQgAvOVVSZ7YaECPJTw3lDJGdVGYKndQKb9JvaVy2REjxSSVu8eLeicvdXljTSi/fFl1RnyKqGdvDIeufgTbUKn5wxHri7o5POBZcJ3j4Tamf1UKpvHdLAlYjjtINtYlOAq2YxRO+5HsJ10Z43LkPZ0sid5h54EClFLQQZF8VYw+EwNp7Yk1h39Mo8ip+pDA067I3ZeSgg5xuryVoDTaMVC7txNGYpVIlJiRgiGcUSV+zi7clgL72W60ycQrU57zfAoNu5e47n9ABlYJSAijL4=" }, { "length": 256, "nonce": "ae7b1f7757691ca191ab671262cda742cba38011c041584b99d8b460e4006e8a", - "payload": "Aq57H3dXaRyhkatnEmLNp0LLo4ARwEFYS5nYtGDkAG6KOOymPU3VIlM30EDqpIUqL7q9L4TL7btTv9o/G85zVxLkL7dACzIcz3v8frQJwJdqS+N9kW+AikH3PQVyT3biutUbsUuo8VM7mJ6Hjn95C7S+o/EleJ3PxhxZ0Egss8I98iRC1Sm8ybBnxoPf1XuCJSxfIbC5R3ENYUlPI9EMcxrlhLwqSeJRvytdY42PQs6X9LNTdq/Ys8qx9HF6t7Oz53g4NEmJjazZHdnmMsew87RrvTKYt+I2xot8MSe8HVo/mRqlX8lJQpMT5Ddg+8D5NW+oIHzCwogQMkqHFKsuyffGdCJusY2IH8ApiZNSPPKBZXbn2NAbFya327o95/7YvtPgdtZ/FhMwO2UIhSDCXHAIRytFvmHLT73XlGfaBGCY4HI=" + "payload": "Aq57H3dXaRyhkatnEmLNp0LLo4ARwEFYS5nYtGDkAG6KsV/GdsA4b5Yq+Qp8GJWcT/II8bxbwy77hWfdxCCYK3k1CRl7/1Xg7dYoLLrEFsN4uP8+CduF7HQKlKG0lapgvYi6rM0vHnhate8NnSzIwVmNNRQRaazdoXtchwPShjnc3h+QvbE6OklpnpEOkNyJYtNykCiNzEWHN++Ob/irBcPgQ6pM+qiyO6hQ28uwIirJbP/P5+scc3iLTTZ3k6ckLBzf+k1ED/s8plFEZOJjJ11/247gi3+M8FVEWYwrk+s25KdO+KqohTfSqG9Z4/kMOuOI9pS7EW/XV+mi0984mFk2180dkpT+hrdfrhFJFkeJN9mZnyWhpvQRvrLpYBPc+ecWudBdcyHg27B4CxAp7uVgF+ZkouzQHdX6dBOATZKS1QE=" }, { "length": 257, "nonce": "93a5444d50668e3593a287aa53f0f316ac08c48efeeece6b6a194e7a6101abff", - "payload": "ApOlRE1QZo41k6KHqlPw8xasCMSO/u7Oa2oZTnphAav/z+OvacjKe1KOUXBAI4Rg3Txts7c4ctZP3OOqOdKmJtGhQbcpF0fygV7DfqpLwn5HnKqhE6LKTnDcOfdWyVc8vqR341PNOW1CG3fEVSbl5SknWK5Ea0+tIiJS+vX3xT5LqAOBk+obTlIUQ+8ije4XzB0hlprDFbcD0MZoSMrZehDN2wY4DH7tzrwE40qIf4CJR7kopfSQ6ZVIfgu7uODoGSPO67b4ziqFXoPXMaFmutbvtHFkheie9+hbGD2FLmGnzZo0OnI+DGpYGJDSq/z8yOFlwVuN+DC+eGaXz0dcOnI6V0lSie1fd5Enplr+qDRF2BAFbnjXoq4Mvx2YX1g9WHC8a7UA4xe5eeBFK5FsW8WDOpl75wiwgOXYLf2IUF0V5bxigIv7SZFKrn4IUlHdPfwP54Ufl5b1U1NuB5yvBRQfUUFnk/+cT1tfwTNBpZyQuwUUdB7p9ZhdZ1oavhU1jAYp" + "payload": "ApOlRE1QZo41k6KHqlPw8xasCMSO/u7Oa2oZTnphAav/BybEo7lEJgVBH5slfDYBNPYL8MbNUCXMpnh7AXBG5y75Pe4wGz4aUg7eJqTNRtuoEabtLDPzOGbQfbLcs4Z7JlM1p7GBOyHicL278lTqrep5bAj8WB++MegODRr2eaJecdhBY5ThSF7/VNve9KZM74rmMMU3PdECNsOm3GH2bm3228B1d43elvYRYDzr+IHDouNfpId3hhrgC0EoKF6gCozU9Qs0LEKWgUTQPCtNRdQTplmjNbUnfMfa0AwHupO8Y53KlkF+ssY5c6LDtzfE5LMJ1Gn5p9QxHhwNYJ+d2bnVH03mCBjjFHVM+FaiNC2pcKJ5JCRjTNooDs5xtXz7DTxzlC/p2a0uXHJJvmJVE8PNUBqJNqVOsMQV8Z/n0K1W99eBmhYuhussi7/uHh1GjJmP7VOuDa0lnXaOajAC1fF34RnMQE0mdpxVdJx9jA+OkigvcUyh+qo/sUyCcKNOUIn8" }, { "length": 300, "nonce": "089ddffec7be570b01f5b9b2810f6eda4234454a9b5298602389f5ab0de19289", - "payload": "Agid3/7HvlcLAfW5soEPbtpCNEVKm1KYYCOJ9asN4ZKJfVUWKb9dak5OZtTNAUsCZuHvJM+yyaHpVCTqhC0edU/2t08c2oedclnEObTV5qoHeHH7O2BubDfJZIIBOiEIxgnACajlUHU7L31DvdXZWyAJr7QuOySpj0Djr5QJ1FBTY+1NT0qsPMiRJqYO5p4P7WsHD4RoT915vPm0DnVL3IksqDBYw4rlj03qIWfZbLEYlAO+vHF8nCeXBfOyJ22uKX1aLZyAb4zz+PQUJbYcorBEy7q44WUeQXfEwVE9jlrxGpiWCC6o+uPkyPRZHyoS20sZ0VvAPvgkYubHCUJvwJ79jcgKwhGtmV9gdSLuk0QvmXdaOnXzcSJ7Ct5RhcsGWabcuUfoyAUrc5G9hpnMtV40LnBUpIB+c9tvGMYEIMB53k0W1iHrFa0LhePDIfQmpl0w/B+ho1XLwEeVTyRovWHrb2xQNmTZQeKQqxCMnN6G0s/aCA/AI1gPbQpKmORqo66i" + "payload": "Agid3/7HvlcLAfW5soEPbtpCNEVKm1KYYCOJ9asN4ZKJ2laj37G4Gg3hiBtyhG+c4BxKE0/XKHDbTj3aNz6mh6N+mKVXm7o5wjne2KB7O9lcaQ4+Al51mpcCc/KmDhfAWtY93CjhSBRKBRGhkBTxYh5vj4WoGI11n5c0uvvBUA0g/6zlhZqoqCkXHkJ80asU54VhlFvJVM4DE7PFd9bna15nfvkc+CG3TTADe7plO2lXgR9tp3l5fcxYGWi2fE4POvYbTPeqGQfB8QzjvN6nxylkvssh7Fi2p4fTbeMs8zoTVNcZ3ZkxWLlIkUNUCK9J89m8nUpfIglRa9HKMq/+Vp+VoTKL49OZk0qBS1nbWbGyXE7hGxuHT/MEv/JexTyRfDAfGU04Esin5ZNOiYTnHjlPYq7zPoDYGRt7zH9Pk357DqtpOR42pBn+RGX/yeNpxnbfYmLTDEmJC2HBtd0NTN+3UWoFZ31K2AIogHARjsCZXwpJFuq6RaxmKAtEK5Bvx8nL" }, { "length": 1000, "nonce": "05628e5d74f4c5083b6e96aa9c29ce88fe3fd8f6efb4539454099c4e9a90b5ea", - "payload": "AgVijl109MUIO26Wqpwpzoj+P9j277RTlFQJnE6akLXqdxUnrD/gOfSFx6cNocWTqRiyA8eXAMzNtADfwVGfTY2HMaNGypY86pBqZDduw+6q3sdThRUT0seaSJkrVYmYLggVmYu7c4e6R25UkScnnlwVNJ6UeHb+mIke2F4LP1ypWigXMhBu06LlyNIzPmpdtNVxh8JvWg+PIxs/nNr70cBaMU2p4zBv3chtvBHnV0LG3kkA4KSwZ2xn99ylBld3k2TdMqM3ZKOoE3I7NaXWqVuEpotcAvcEDILdoCXB2zlHUnNLUME4lTn6vVjYf2Zhn66xo85XKeD0JJZgMYTkXz4pEJpUzwSbwz2WOpGEqVqcpC5TVZXSupmD0ofXKo2EF0eHYvzU8Yn0qcd66IZVI4zwbHRKF/vcPfi8aeTTgcolJ8ctAQFkbBFcrO6C32RoQf3Vkk/6181iXUb95zV1xHl+VXJw65vEwlLaKzAuzO2WIvKEI6gn4gH5QvDMpOoxScbeVl0eg35/KUkr7kDAyRe+LFv/HgGLmEHrnmTuvIXE06KrbjhALnqSZlDnP1SJdwirJPph7wZaz+nAljc2J0klUF0Gu5sCTB+5jBtwNdmc9HHwMdhU3193wAinlGFqEOzx4B4KrTG3M0JhUf9BKwo31rAju9tlWDf8d9119oSg9Ft5R8qypf0QU45aRBKcmok0pTwWhrdExPqS4K2iLcPhGNyc2X4oaGfrgq72gssIqOm8oS88WgALb39VifFkRanYXucTu+fG7ak4jBQVJIAroyfSKFqSqDVn2eGmSAWE4LbSZYnrr8iTW1jRqAUjp/SDTigJ8iFp7/B1Yk+su6WcL3AELAvHwbc/mvI1obLihXbKw+tvmJ7oAsNAdR8CWzOT15FYuRScQpRoq7DCXsrsnd1KqA3qRQYOWbXi2x1RHtp2uMcbWy4eKIfE17YSerfNoPyZMditBnx0nxlTS2tAOvYlT2ACDdc/jSaMm4Uk3Wqdbv9jaJ7bF7CpjJGa82KhKUFwW0L48DgAJCyrEQd9+8rXuTjyWvgLfYsv/2udAh3zzIVfLaTujsbQPeHV5+F5gMDyby5yIq0ruPZGmBn/Y/BQli2r1vLaWS8UaI+0pS1qOWdkXjMMCX1EZeK4pBWheZndnbgWsbKzwnmvvRPydn3QDUG5b9Yl8ADs7CDuMsCFNUnF4QC2uIHKtfkboquk5tIaXUHjxj6e9h5vcfchLChHKSVI9zwtke+Oqldoj2D30d5+Xza55mHhuFd+PXofUpW/Se09DxQ2YJjuHMR9y/fx3PD+9BBNmXtGbP207vEWEUvahXiP06s86g3lO7FHPDiP8cCW4zbfkLWypT+7VEV8lpuffLfuug6eDWhzIesXaCC2Qtcgh6a6iFRop50cbL3mFO0ZRSjDqshZLHFgg5LEgK679DOLZZDy7qEBLfk=" + "payload": "AgVijl109MUIO26Wqpwpzoj+P9j277RTlFQJnE6akLXqRkaCnKdyKOmZIzjSMNVMl4MfQuVyLsgZZjnBXXDdr3DBaHeL6/565vFNiaqyAd6EmoqzGK4Br5LB6MPnw2BKJlUGy75obSvMH4A8wJnEPseg3tmCtsyUVGnsnM1IdURZSUvZHeAvfqW5AghpoYqO2IwxRCjxPzyhz8kZuAnoE7WMeeUZx6i7sWiv0nNLLGgQVfiFUmFUZs0rh1pYBBeAj3Qfj8dT3gcZ5UNQ1YlGIa9Vl9HDGpJFqzWaYBCelTcAKSiSmzhDPiCxrJtUYVAApHgezyFFOald5HpBvXsnoEJi78xjIWs4ADHXTDe7jtyD3wdsV4u8iwsfe8o0pdJsHeI+cHAlgHeK5Mm/bNyuGuqduFVMLRnkZk+ltgHDdcoz9C8z5L6lW4giV394niY8OeiD1lmYaTKe7H1ZW58v0Hc1EejWGLwi33nmuIRYDYIk9Hzo//RzgXcLWFHRHK58Q3bwNDGcCTWdBY7uk5GQJc/O6Aj6lLB5l5jhORgEq0HAQcoiPFnulWErEazey11ApgqWt9jXUsHUYmtZLYhZED7x3A5NC4BbjIjFXUk3zE8w21mO8+OFr5YX91tszcm9JiGgxyyFlcl/IcKjOPYoMgPTctVb43Za+kfJEYwueGaFBx9ZqikPvigZ68+5Jp6xJZpDTuEzXSiQHufZoeYkC1hy6phBz50/IoMkjZyboQMroMPSsvpwIL1SkQ0gOa65lcobYdQeHyOTDetcfBz235z3zP034MkcP5FBM7Lc7zrnrTNjSzv88HlHA8hu7HvKT+2eUjn6ONn7Pez7UqmcMp3LMXjW3qPU5Ax1yTN3hlMrHhd1mEwoo/x24KkTuSRQrwHsDNaPZEahMG0nBANWMSXo9RGPA9qHkyWb9Obg9kRE6o6W8jmQ6fWNhVPiMB6xOIScwFXJAy9Nh6DlLiEz5FmCU6gl0ytBUeRRj+bOZkpXN7U+d9Gu3N5OvbKSoVboiUwE3Pc3A9le+CZZzfbKsFhS9WjQcMbZOTiN1pOM3vQa9iB8wLZhycRaamOKznADwkNbmCZorzqfAHzZcCkthx+lGEvcG9bhpwtvyUzQEW4dsEmSPCAWxKk98lvWYqJdncrdL6W9XkfI5MccRbnBSfF6XCT71/q9RmlLK7ClhCI8NaRP/ImRswJXjgGIIwrsXRC/LoJTpk7w24BKueNW/mp4SZRUyVh3C1ZkT2/EkEUoGzJ2T5903R1nT0c5gzvii81rtxGkM80sd5XhEpMB/WRs88z563oMNkNCPVF9/gcDwwm4Tdbn9c26hRyXvXm1Ugx8Mk+DcU8zHOM+7CMRNWg/BGZy1D/KJ6nXv7hW5JcipF3FeOIUSRN/7MsQvMu1AVDd5R2p2gXVksWRWdPV8XMBOayTdEPP4d+S2d72JEDubi8=" }, { "length": 4096, "nonce": "dbd98cc308d689fa14abf8fc129ef0d3699d3e327d570fbca415de67f480af1e", - "payload_sha256": "8363eee4d23b8e17e8911bf32fcca4ee860b5976fd70b38ede3c050832a96f26" + "payload_sha256": "046d0589edfde9a8a8b7503c17983f9ed927f86ab86f2531c638b6d981675caa" }, { "length": 16385, "nonce": "a76a39705cf4744e4d07ff4bd8bb622bc1b9db21552d3416c47118ef1c74d2c0", - "payload_sha256": "70273468e08e9cb97b1ccf2aa4150726bc11bbade4de0aa51a2dd71bd54379bf" + "payload_sha256": "03dc8d7692fabbe0de4e6035ee18e753c6b37cf81b08439235289e76b4db359b" }, { "length": 65408, "nonce": "914a30009dc97047128a85142f1c56b96bc476b37d163f2ac11e1f7769a6684f", - "payload_sha256": "0183d8e98013085ff901e12019edf60fb343de5fae8b57acec41eadc2e7a514f" + "payload_sha256": "c9d5e1711f4531602ea90aea12b402ca600b085eeca17418c295bfb34105d7d8" } ], "peer_pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", "peer_secret": "e0ba0a9c6583de51b416b8cfa5ecfb0810918f28bfdc3d1834f9c3862097c0e8", "proofs": [ { - "proof": "c2eff7c468258ae4eae0c2054100944b7b9247468d034ff168f51fc2093bf86e98c238146f23cd4276d7bd10811902703c9fcb339caecb0667a5a9ab30960680", + "proof": "457a841726df7babfff2e9d1922aa81ceda096dc8cc47cdbe474091fa1243a55b46cd995c0450ef8edd39d160f967180639d0309a4108da9b85c4e5cf79a24cb", "timestamp": 0 }, { - "proof": "8f6a9d3602ee52c27918f8a5fec2e8734051a4c1bba83bb786a5f358748bbe9a7ecd9856d1ddd41151d24658fc54787e4d3ba44fdeb0939a6209b4e180912351", + "proof": "f585b6cf4ff312de2ad0547b2668c6427eb06100e0d525e5726d452e08b0aa4fb6cd548544ab942324e87c332233ad5f21c9d0e3bcb1ac8fcc08eed6f020bc64", "timestamp": 1700000000 }, { - "proof": "4a9f11a71e3b37d4c4aa9eacbfc7f9d964c829601e8d5b432b5a3a99a1356d8891e4fdf1945d72e4144caf0a002876f28d6d4af1125c558b49355e1aa09076c6", + "proof": "963cbd36a1a98e0f0fd4d43733855b22b2fa568f7ce9708c773429a6ebc5476df36b1c6571b6091927350748b4d7b730f7a5dfde5eb123fded1a7788cdeaa3be", "timestamp": 18446744073709551615 } ], - "transport_pubkey": "fb8e586fb189823b880152127ea501fb8a862147d84a6df8baf16f9e2834533f" + "transport_pubkey": "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" } ], "min_signers": 3 @@ -1915,12 +1915,12 @@ ], "serializations": [ { - "id": "fb817a2821993919bf534c84251bcfcc5c7e90b8e7cd95dec5f7f2f45382fbc3", - "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791465433,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"pong\"]],\"AuGxf6smVEfthQQGjEc7RfZjvuxelhNVWgXq8U9lCjeU7LhXAfh4/ay6DP13CHFgOIat5HZkqU+c+8VM8MBsgusMzh1rwsNEUkiZQOhrA0euCKyw3jmvFOBlX6AqKmlsF3KbOBktE4XEid8dqTcGqiCHLmtPrM8yWInXbx+23puDi1OwZQYtUb96eEw+mVHkzF9604JSNriHTeITBFDGy8nl0WvpV2m7K9z+aopDZmDhOzXzsL7CO3M+kdD74fA/x3+e\"]" + "id": "fa7698ec16b6e398d20a46a34242995866eccc9a2f9a24eaf58b42a8112fbe1e", + "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791467348,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"pong\"]],\"AnBBdUe91DHwrJs8hdaN9GOocyRiETBmmax0QZ2Au5ZbDnMTVSMfJWsoX/0TKyBWVQRiIobn0VxSWktSJ6IDwhfkNquyoEvAPdBAk8OyD9DOgbs4avJUq5f3XEX3E7OIaK37xqWn357U3dYXHp8VJBV8jOlQ252CX+/wEhom0PwHA85KBk5khBxMkO8ioY8KPlTzUsFYfdFVLjEsFk6tFQP3MvNCHBswnMug/V9AYngx33cRTJJXYhrOZfGBeA6po659\"]" }, { - "id": "2b44cbb6be46554a6085a77978502adecaaab19c941458695c45c6679c683e1b", - "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791465434,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"x\\\"y\"]],\"line\\nbreak \\\"quote\\\" back\\\\slash \\t tab \\b \\f \\r \u00e9 \u2713\"]" + "id": "2160ed2433c542b0605bbc5da71f3a799cee4302584d7527d24c6fdfe4c2014a", + "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791467352,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"x\\\"y\"]],\"line\\nbreak \\\"quote\\\" back\\\\slash \\t tab \\b \\f \\r \u00e9 \u2713\"]" } ], "sessions": [ @@ -1997,5 +1997,5 @@ "threshold": 2 } ], - "source": "keep-core/keep-frost-net cdc47dd and nostr 0.44.7" + "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (vectors/gen-kfp)" } From a05bf439824830da92a5c12eb90024d6bc4c9483 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20=F0=9F=90=86?= Date: Thu, 8 Oct 2026 09:58:00 -0400 Subject: [PATCH 3/5] Refuse overlapping NIP-44 buffers and check the proof against the stored share --- components/frost_tr/include/frost_tr.h | 4 +++- components/frost_tr/rust/src/kfp.rs | 10 +++++++--- components/frost_tr/rust/src/lib.rs | 18 ++++++++++++++++-- 3 files changed, 26 insertions(+), 6 deletions(-) diff --git a/components/frost_tr/include/frost_tr.h b/components/frost_tr/include/frost_tr.h index e0d3238..9afb33c 100644 --- a/components/frost_tr/include/frost_tr.h +++ b/components/frost_tr/include/frost_tr.h @@ -102,7 +102,9 @@ int ftr_sign(const uint8_t *kp, size_t kp_len, uint8_t nonces[FTR_NONCES_LEN], bool taproot, const uint8_t *merkle_root, uint8_t out_share[FTR_SIGNATURE_SHARE_LEN]); // KFP v2 (keep-frost-net), with the transport key derived inside from the key -// package, so it never leaves the device and no caller supplies it. +// package, so it never leaves the device and no caller supplies it. As for +// every function here, no output buffer may overlap an input; seal and open +// refuse one that does. // The x-only transport public key keep derives from the key package. int ftr_kfp_transport_pubkey(const uint8_t *kp, size_t kp_len, uint8_t out[32]); diff --git a/components/frost_tr/rust/src/kfp.rs b/components/frost_tr/rust/src/kfp.rs index be8f507..a91f630 100644 --- a/components/frost_tr/rust/src/kfp.rs +++ b/components/frost_tr/rust/src/kfp.rs @@ -120,9 +120,13 @@ pub(crate) fn announce_proof_with_aux( let share = Zeroizing::new(kp.signing_share().serialize()); let key = SigningKey::from_bytes(&share).map_err(|_| E_KEY)?; let sig = key.sign_raw(&message, aux).map_err(|_| E_KEY)?; - // Recomputing the signature's validity catches a fault injected into the - // signing above before the signature leaves the device. - key.verifying_key().verify_raw(&message, &sig).map_err(|_| E_SELFCHECK)?; + // Checking the signature against the stored verifying share catches a + // fault injected into the signing, or into the share it used, before the + // signature leaves the device. + let verifying_share = kp.verifying_share().serialize().map_err(|_| E_KEY)?; + k256::schnorr::VerifyingKey::from_bytes(&verifying_share[1..]) + .and_then(|vk| vk.verify_raw(&message, &sig)) + .map_err(|_| E_SELFCHECK)?; Ok(sig.to_bytes()) } diff --git a/components/frost_tr/rust/src/lib.rs b/components/frost_tr/rust/src/lib.rs index 3e5caa0..7259abf 100644 --- a/components/frost_tr/rust/src/lib.rs +++ b/components/frost_tr/rust/src/lib.rs @@ -182,6 +182,13 @@ pub unsafe extern "C" fn ftr_sign( status(signer::sign(kp, nonces, sp, msg, path, taproot, share)) } +/// Whether two byte ranges share any address: an output must never alias an +/// input passed alongside it. +fn overlaps(a: *const u8, a_len: usize, b: *const u8, b_len: usize) -> bool { + let (a, b) = (a as usize, b as usize); + a < b.saturating_add(b_len) && b < a.saturating_add(a_len) +} + fn kfp_key(kp: *const u8, kp_len: usize) -> Result { signer::load(unsafe { slice(kp, kp_len) }.ok_or(signer::E_NULL)?) } @@ -240,7 +247,7 @@ pub unsafe extern "C" fn ftr_kfp_seal( else { return signer::E_NULL; }; - if out.is_null() { + if out.is_null() || overlaps(plaintext.as_ptr(), plaintext.len(), out, cap) { return signer::E_NULL; } let out = core::slice::from_raw_parts_mut(out, cap); @@ -267,7 +274,7 @@ pub unsafe extern "C" fn ftr_kfp_open( let (Some(sender), Some(payload), Some(out_len)) = (sender.as_ref(), slice(payload, payload_len), out_len.as_mut()) else { return signer::E_NULL; }; - if out.is_null() { + if out.is_null() || overlaps(payload.as_ptr(), payload.len(), out, cap) { return signer::E_NULL; } let out = core::slice::from_raw_parts_mut(out, cap); @@ -1172,6 +1179,13 @@ mod tests { let r = unsafe { ftr_kfp_open(kp.as_ptr(), kp.len(), &peer, good.as_ptr(), good.len(), out.as_mut_ptr(), out.len(), &mut len) }; assert_eq!(r, kfp::E_CAPACITY); assert_eq!(out, [0u8; 4], "nothing written when it does not fit"); + // In place is refused: the output may not alias the input. + let mut buf = good.clone(); + let r = unsafe { ftr_kfp_open(kp.as_ptr(), kp.len(), &peer, buf.as_ptr(), buf.len(), buf.as_mut_ptr(), buf.len(), &mut len) }; + assert_eq!(r, signer::E_NULL); + let mut buf = vec![b'x'; 256]; + let r = unsafe { ftr_kfp_seal(kp.as_ptr(), kp.len(), &peer, buf.as_ptr(), 5, buf.as_mut_ptr().add(4), 200, &mut len) }; + assert_eq!(r, signer::E_NULL); let mut sealed = [0u8; 8]; let r = unsafe { ftr_kfp_seal(kp.as_ptr(), kp.len(), &peer, b"x".as_ptr(), 1, sealed.as_mut_ptr(), sealed.len(), &mut len) }; assert_eq!(r, kfp::E_CAPACITY); From 1379e7ead0ed24ed1b9f1dfdaef2485f760d3f90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20=F0=9F=90=86?= Date: Thu, 8 Oct 2026 09:58:41 -0400 Subject: [PATCH 4/5] State which overlaps seal and open refuse --- components/frost_tr/include/frost_tr.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/frost_tr/include/frost_tr.h b/components/frost_tr/include/frost_tr.h index 9afb33c..40e4b0c 100644 --- a/components/frost_tr/include/frost_tr.h +++ b/components/frost_tr/include/frost_tr.h @@ -104,7 +104,7 @@ int ftr_sign(const uint8_t *kp, size_t kp_len, uint8_t nonces[FTR_NONCES_LEN], // KFP v2 (keep-frost-net), with the transport key derived inside from the key // package, so it never leaves the device and no caller supplies it. As for // every function here, no output buffer may overlap an input; seal and open -// refuse one that does. +// also refuse an output that overlaps their plaintext or payload. // The x-only transport public key keep derives from the key package. int ftr_kfp_transport_pubkey(const uint8_t *kp, size_t kp_len, uint8_t out[32]); From 69081d7bf788fc59a5c1efee3cfc5decf40a667e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20=F0=9F=90=86?= Date: Thu, 8 Oct 2026 10:05:30 -0400 Subject: [PATCH 5/5] Move the KFP vector generator under test and stop tracking its lockfile --- .../frost_tr/rust/vectors/gen-kfp/.gitignore | 1 - .../frost_tr/rust/vectors/gen-kfp/Cargo.lock | 3830 ----------------- components/frost_tr/rust/vectors/kfp.json | 2 +- test/vectors/gen-kfp/.gitignore | 2 + .../rust => test}/vectors/gen-kfp/Cargo.toml | 0 .../rust => test}/vectors/gen-kfp/src/main.rs | 9 +- 6 files changed, 9 insertions(+), 3835 deletions(-) delete mode 100644 components/frost_tr/rust/vectors/gen-kfp/.gitignore delete mode 100644 components/frost_tr/rust/vectors/gen-kfp/Cargo.lock create mode 100644 test/vectors/gen-kfp/.gitignore rename {components/frost_tr/rust => test}/vectors/gen-kfp/Cargo.toml (100%) rename {components/frost_tr/rust => test}/vectors/gen-kfp/src/main.rs (95%) diff --git a/components/frost_tr/rust/vectors/gen-kfp/.gitignore b/components/frost_tr/rust/vectors/gen-kfp/.gitignore deleted file mode 100644 index 2f7896d..0000000 --- a/components/frost_tr/rust/vectors/gen-kfp/.gitignore +++ /dev/null @@ -1 +0,0 @@ -target/ diff --git a/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock b/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock deleted file mode 100644 index 3a09267..0000000 --- a/components/frost_tr/rust/vectors/gen-kfp/Cargo.lock +++ /dev/null @@ -1,3830 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 4 - -[[package]] -name = "aead" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" -dependencies = [ - "crypto-common 0.1.7", - "generic-array 0.14.7", -] - -[[package]] -name = "aead" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1973cfbc1a2daf9cf550e74e1f088c28e7f7d8c1e1418fb6c9dc5184b7e84c99" -dependencies = [ - "crypto-common 0.2.2", - "inout 0.2.2", -] - -[[package]] -name = "aes" -version = "0.8.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" -dependencies = [ - "cfg-if", - "cipher 0.4.4", - "cpufeatures 0.2.17", -] - -[[package]] -name = "aes" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35f0f96ce78e38c3dc6d8948aa8163d06385be74000f3c7a95bf1eef35d3ea32" -dependencies = [ - "cipher 0.5.2", - "cpubits", - "cpufeatures 0.3.0", -] - -[[package]] -name = "aes-gcm" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2b8006a0c83f52b62ba44a97b58bf76fe2f70a329e588f67f89691d93d498f" -dependencies = [ - "aead 0.6.1", - "aes 0.9.3", - "cipher 0.5.2", - "ctr", - "ctutils", - "ghash", -] - -[[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 = "argon2" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072" -dependencies = [ - "base64ct", - "blake2", - "cpufeatures 0.2.17", - "password-hash", -] - -[[package]] -name = "arrayref" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" - -[[package]] -name = "arrayvec" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" -dependencies = [ - "zeroize", -] - -[[package]] -name = "ascon-aead" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17453125d1e5c866b1f38bcccf7b9dd4a561f55930c68685ec8f188d01f71c8c" -dependencies = [ - "aead 0.5.2", - "ascon-core", - "subtle", - "zeroize", -] - -[[package]] -name = "ascon-core" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c4c9bc969387b7d7e7e931b978833ab18251a39e0f94addad7b823d08b8db74" -dependencies = [ - "zeroize", -] - -[[package]] -name = "async-utility" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a34a3b57207a7a1007832416c3e4862378c8451b4e8e093e436f48c2d3d2c151" -dependencies = [ - "futures-util", - "gloo-timers", - "tokio", - "wasm-bindgen-futures", -] - -[[package]] -name = "async-wsocket" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c92385c7c8b3eb2de1b78aeca225212e4c9a69a78b802832759b108681a5069" -dependencies = [ - "async-utility", - "futures", - "futures-util", - "js-sys", - "tokio", - "tokio-rustls", - "tokio-socks", - "tokio-tungstenite", - "url", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "atomic-destructor" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef49f5882e4b6afaac09ad239a4f8c70a24b8f2b0897edb1f706008efd109cf4" - -[[package]] -name = "atomic-polyfill" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4" -dependencies = [ - "critical-section", -] - -[[package]] -name = "autocfg" -version = "1.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" - -[[package]] -name = "aws-lc-rs" -version = "1.18.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e" -dependencies = [ - "aws-lc-sys", - "zeroize", -] - -[[package]] -name = "aws-lc-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27" -dependencies = [ - "cc", - "cmake", - "dunce", - "fs_extra", - "pkg-config", -] - -[[package]] -name = "base16ct" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" - -[[package]] -name = "base58ck" -version = "0.1.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "365c0acd5b2e8dd0111a46c4faea83fb3cfb6e39a49a7c73a06e090db7b2eff0" -dependencies = [ - "bitcoin_hashes", -] - -[[package]] -name = "base64" -version = "0.21.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" - -[[package]] -name = "base64" -version = "0.22.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" - -[[package]] -name = "base64" -version = "0.23.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" - -[[package]] -name = "base64ct" -version = "1.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" - -[[package]] -name = "bech32" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32637268377fc7b10a8c6d51de3e7fba1ce5dd371a96e342b34e6078db558e7f" - -[[package]] -name = "bech32" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8" - -[[package]] -name = "bincode" -version = "1.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" -dependencies = [ - "serde", -] - -[[package]] -name = "bip39" -version = "2.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc" -dependencies = [ - "bitcoin_hashes", - "serde", - "unicode-normalization", - "zeroize", -] - -[[package]] -name = "bitcoin" -version = "0.32.102" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb0ce8bd5baaa0d303a19915a6d93afed161f528654e42da2a7a97d05c59499a" -dependencies = [ - "base58ck", - "base64 0.21.7", - "bech32 0.11.1", - "bitcoin-io", - "bitcoin-units", - "bitcoin_hashes", - "hex-conservative 0.2.2", - "hex_lit", - "secp256k1", - "serde", -] - -[[package]] -name = "bitcoin-consensus-encoding" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2d6094e2a1ba3c93b5a596fe5a10d1a10c3c6e06785cde89f693a044c01aa40" -dependencies = [ - "bitcoin-internals", -] - -[[package]] -name = "bitcoin-internals" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a30a22d1f112dde8e16be7b45c63645dc165cef254f835b3e1e9553e485cfa64" -dependencies = [ - "hex-conservative 0.3.2", -] - -[[package]] -name = "bitcoin-io" -version = "0.1.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb5de036369d1ac59d3c1819ebc4d850f89466f5401c571a285b6ed564a4cb78" -dependencies = [ - "bitcoin-consensus-encoding", -] - -[[package]] -name = "bitcoin-units" -version = "0.1.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cb95693f371d089a4b5b6fc41c6f3ea6e01ee8c15388335dfac8ea685173b51" -dependencies = [ - "bitcoin-consensus-encoding", - "serde", -] - -[[package]] -name = "bitcoin_hashes" -version = "0.14.101" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2" -dependencies = [ - "bitcoin-io", - "hex-conservative 0.2.2", - "serde", -] - -[[package]] -name = "bitflags" -version = "2.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" - -[[package]] -name = "bitvec" -version = "1.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837" -dependencies = [ - "funty", - "radium", - "tap", - "wyz", -] - -[[package]] -name = "blake2" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" -dependencies = [ - "digest 0.10.7", -] - -[[package]] -name = "blake3" -version = "1.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0aa83c34e62843d924f905e0f5c866eb1dd6545fc4d719e803d9ba6030371fce" -dependencies = [ - "arrayref", - "arrayvec", - "cc", - "cfg-if", - "constant_time_eq", - "cpufeatures 0.3.0", -] - -[[package]] -name = "block-buffer" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" -dependencies = [ - "generic-array 0.14.7", -] - -[[package]] -name = "block-buffer" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be" -dependencies = [ - "hybrid-array", -] - -[[package]] -name = "block-padding" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" -dependencies = [ - "generic-array 0.14.7", -] - -[[package]] -name = "block-padding" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "710f1dd022ef4e93f8a438b4ba958de7f64308434fa6a87104481645cc30068b" -dependencies = [ - "hybrid-array", -] - -[[package]] -name = "borsh" -version = "1.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a" -dependencies = [ - "borsh-derive", - "bytes", - "cfg_aliases", -] - -[[package]] -name = "borsh-derive" -version = "1.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59" -dependencies = [ - "once_cell", - "proc-macro-crate", - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "bumpalo" -version = "3.20.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" - -[[package]] -name = "byteorder" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" - -[[package]] -name = "bytes" -version = "1.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" - -[[package]] -name = "cbc" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6" -dependencies = [ - "cipher 0.4.4", -] - -[[package]] -name = "cbc" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce2dc9ee5f88d11e0beb842c88b33c8a5cf0d1329c4b19494af42b07dbfe8896" -dependencies = [ - "cipher 0.5.2", -] - -[[package]] -name = "cc" -version = "1.2.63" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "556e016178bb5662a08681bbe0f00f8e17631781a4dfc8c45e466e4b185ec27f" -dependencies = [ - "find-msvc-tools", - "jobserver", - "libc", - "shlex", -] - -[[package]] -name = "cfg-if" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" - -[[package]] -name = "cfg_aliases" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" - -[[package]] -name = "chacha20" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" -dependencies = [ - "cfg-if", - "cipher 0.4.4", - "cpufeatures 0.2.17", -] - -[[package]] -name = "chacha20" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" -dependencies = [ - "cfg-if", - "cipher 0.5.2", - "cpufeatures 0.3.0", - "rand_core 0.10.1", -] - -[[package]] -name = "chacha20poly1305" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35" -dependencies = [ - "aead 0.5.2", - "chacha20 0.9.1", - "cipher 0.4.4", - "poly1305 0.8.0", - "zeroize", -] - -[[package]] -name = "chacha20poly1305" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b89e1c441e926b9c82a8d023f6e1b7ae0adcfaa7d621814e4d60789bac751cb" -dependencies = [ - "aead 0.6.1", - "chacha20 0.10.2", - "cipher 0.5.2", - "poly1305 0.9.0", -] - -[[package]] -name = "chrono" -version = "0.4.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" -dependencies = [ - "iana-time-zone", - "js-sys", - "num-traits", - "serde", - "wasm-bindgen", - "windows-link", -] - -[[package]] -name = "ciborium" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e" -dependencies = [ - "ciborium-io", - "ciborium-ll", - "serde", -] - -[[package]] -name = "ciborium-io" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757" - -[[package]] -name = "ciborium-ll" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9" -dependencies = [ - "ciborium-io", - "half", -] - -[[package]] -name = "cipher" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" -dependencies = [ - "crypto-common 0.1.7", - "inout 0.1.4", - "zeroize", -] - -[[package]] -name = "cipher" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c" -dependencies = [ - "block-buffer 0.12.0", - "crypto-common 0.2.2", - "inout 0.2.2", -] - -[[package]] -name = "cmake" -version = "0.1.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" -dependencies = [ - "cc", -] - -[[package]] -name = "cmov" -version = "0.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a" - -[[package]] -name = "cobs" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1" -dependencies = [ - "thiserror 2.0.21", -] - -[[package]] -name = "const-crc32-nostd" -version = "1.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "808ac43170e95b11dd23d78aa9eaac5bea45776a602955552c4e833f3f0f823d" - -[[package]] -name = "const-oid" -version = "0.9.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" - -[[package]] -name = "const-oid" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" - -[[package]] -name = "constant_time_eq" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b" - -[[package]] -name = "core-foundation-sys" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" - -[[package]] -name = "cpubits" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae" - -[[package]] -name = "cpufeatures" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" -dependencies = [ - "libc", -] - -[[package]] -name = "cpufeatures" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" -dependencies = [ - "libc", -] - -[[package]] -name = "critical-section" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b" - -[[package]] -name = "crunchy" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" - -[[package]] -name = "crypto-bigint" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" -dependencies = [ - "generic-array 0.14.7", - "rand_core 0.6.4", - "serdect 0.2.0", - "subtle", - "zeroize", -] - -[[package]] -name = "crypto-bigint" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96272c2ff28b807e09250b180ad1fb7889a3258f7455759b5c3c58b719467130" -dependencies = [ - "num-traits", - "rand_core 0.6.4", - "serdect 0.3.0", - "subtle", - "zeroize", -] - -[[package]] -name = "crypto-common" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" -dependencies = [ - "generic-array 0.14.7", - "rand_core 0.6.4", - "typenum", -] - -[[package]] -name = "crypto-common" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" -dependencies = [ - "getrandom 0.4.3", - "hybrid-array", - "rand_core 0.10.1", -] - -[[package]] -name = "ctr" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21" -dependencies = [ - "cipher 0.5.2", -] - -[[package]] -name = "ctutils" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e" -dependencies = [ - "cmov", -] - -[[package]] -name = "curve25519-dalek" -version = "4.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" -dependencies = [ - "cfg-if", - "cpufeatures 0.2.17", - "curve25519-dalek-derive", - "fiat-crypto", - "rand_core 0.6.4", - "rustc_version", - "subtle", - "zeroize", -] - -[[package]] -name = "curve25519-dalek-derive" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "data-encoding" -version = "2.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8" - -[[package]] -name = "der" -version = "0.7.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" -dependencies = [ - "const-oid 0.9.6", - "pem-rfc7468 0.7.0", - "zeroize", -] - -[[package]] -name = "der" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a878c850e9e421b20262e9b41f9c860e4785fa07541c266b62ff9d1ef998a80a" -dependencies = [ - "const-oid 0.10.2", - "der_derive", - "flagset", - "pem-rfc7468 1.0.0", - "zeroize", -] - -[[package]] -name = "der_derive" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59600e2c2d636fde9b65e99cc6445ac770c63d3628195ff39932b8d6d7409903" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "derive-getters" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74ef43543e701c01ad77d3a5922755c6a1d71b22d942cb8042be4994b380caff" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "derive-where" -version = "1.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "digest" -version = "0.10.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" -dependencies = [ - "block-buffer 0.10.4", - "const-oid 0.9.6", - "crypto-common 0.1.7", - "subtle", -] - -[[package]] -name = "digest" -version = "0.11.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" -dependencies = [ - "block-buffer 0.12.0", - "const-oid 0.10.2", - "crypto-common 0.2.2", - "ctutils", -] - -[[package]] -name = "dirs" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" -dependencies = [ - "dirs-sys", -] - -[[package]] -name = "dirs-sys" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" -dependencies = [ - "libc", - "option-ext", - "redox_users", - "windows-sys 0.61.2", -] - -[[package]] -name = "displaydoc" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ac70aa55017e108007fbaf5aa0f54b021c98f92ff8af59d42eda9da96e3dd4f" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "document-features" -version = "0.2.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" -dependencies = [ - "litrs", -] - -[[package]] -name = "dunce" -version = "1.0.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" - -[[package]] -name = "ecdsa" -version = "0.16.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" -dependencies = [ - "der 0.7.10", - "digest 0.10.7", - "elliptic-curve", - "rfc6979", - "signature 2.2.0", - "spki 0.7.3", -] - -[[package]] -name = "either" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e" - -[[package]] -name = "elliptic-curve" -version = "0.13.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" -dependencies = [ - "base16ct", - "crypto-bigint 0.5.5", - "digest 0.10.7", - "ff", - "generic-array 0.14.7", - "group", - "hkdf 0.12.4", - "pem-rfc7468 0.7.0", - "pkcs8", - "rand_core 0.6.4", - "sec1", - "subtle", - "tap", - "zeroize", -] - -[[package]] -name = "elliptic-curve-tools" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1de2b6fae800f08032a6ea32995b52925b1d451bff9d445c8ab2932323277faf" -dependencies = [ - "elliptic-curve", - "heapless 0.8.0", - "hex", - "multiexp", - "serde", - "zeroize", -] - -[[package]] -name = "embedded-io" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced" - -[[package]] -name = "embedded-io" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d" - -[[package]] -name = "equivalent" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" - -[[package]] -name = "errno" -version = "0.3.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - -[[package]] -name = "ff" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" -dependencies = [ - "bitvec", - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "fiat-crypto" -version = "0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" - -[[package]] -name = "find-msvc-tools" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" - -[[package]] -name = "flagset" -version = "0.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe" - -[[package]] -name = "foldhash" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" - -[[package]] -name = "form_urlencoded" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" -dependencies = [ - "percent-encoding", -] - -[[package]] -name = "frost-core" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81ef2787af391c7e8bedc037a3b9ea03dde803fbd93e778e6bb369547800e5cd" -dependencies = [ - "byteorder", - "const-crc32-nostd", - "derive-getters", - "document-features", - "hex", - "itertools", - "postcard", - "rand_core 0.6.4", - "serde", - "serdect 0.2.0", - "thiserror 2.0.21", - "visibility", - "zeroize", - "zeroize_derive", -] - -[[package]] -name = "frost-rerandomized" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f4c5cedd2426728adef2c0b1720f57676354c473836d1ccc50d0f0d1c91942b" -dependencies = [ - "derive-getters", - "document-features", - "frost-core", - "hex", - "rand_core 0.6.4", -] - -[[package]] -name = "frost-secp256k1-tr" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6fca4ca9f057cf22066f3eb5bbda59d2af51f429f2aac5982a11a8a841c0993" -dependencies = [ - "document-features", - "frost-core", - "frost-rerandomized", - "k256", - "rand_core 0.6.4", - "sha2 0.10.9", -] - -[[package]] -name = "fs2" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" -dependencies = [ - "libc", - "winapi", -] - -[[package]] -name = "fs_extra" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" - -[[package]] -name = "funty" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" - -[[package]] -name = "futures" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" - -[[package]] -name = "futures-io" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" - -[[package]] -name = "futures-sink" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" - -[[package]] -name = "futures-task" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" - -[[package]] -name = "futures-util" -version = "0.3.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-sink", - "futures-task", - "memchr", - "pin-project-lite", - "slab", -] - -[[package]] -name = "gen-kfp" -version = "0.0.0" -dependencies = [ - "frost-secp256k1-tr", - "hex", - "keep-core", - "keep-frost-net", - "nostr-relay-builder", - "nostr-sdk", - "rustls", - "serde_json", - "tokio", -] - -[[package]] -name = "generic-array" -version = "0.14.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" -dependencies = [ - "typenum", - "version_check", - "zeroize", -] - -[[package]] -name = "generic-array" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2e55f16dcf0e9c00efbe2e655ffe45fc98e7066b52bc92f8a79e64060a79351" -dependencies = [ - "rustversion", - "serde_core", - "typenum", -] - -[[package]] -name = "getrandom" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" -dependencies = [ - "cfg-if", - "js-sys", - "libc", - "wasi", - "wasm-bindgen", -] - -[[package]] -name = "getrandom" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" -dependencies = [ - "cfg-if", - "libc", - "r-efi 5.3.0", - "wasip2", -] - -[[package]] -name = "getrandom" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" -dependencies = [ - "cfg-if", - "libc", - "r-efi 6.0.0", - "rand_core 0.10.1", -] - -[[package]] -name = "ghash" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5" -dependencies = [ - "polyval", -] - -[[package]] -name = "gloo-timers" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" -dependencies = [ - "futures-channel", - "futures-core", - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "group" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" -dependencies = [ - "ff", - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "half" -version = "2.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b" -dependencies = [ - "cfg-if", - "crunchy", - "zerocopy", -] - -[[package]] -name = "hash32" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67" -dependencies = [ - "byteorder", -] - -[[package]] -name = "hash32" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" -dependencies = [ - "byteorder", -] - -[[package]] -name = "hashbrown" -version = "0.16.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" -dependencies = [ - "foldhash", -] - -[[package]] -name = "hashbrown" -version = "0.17.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" - -[[package]] -name = "heapless" -version = "0.7.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f" -dependencies = [ - "atomic-polyfill", - "hash32 0.2.1", - "rustc_version", - "serde", - "spin 0.9.8", - "stable_deref_trait", -] - -[[package]] -name = "heapless" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" -dependencies = [ - "hash32 0.3.1", - "stable_deref_trait", -] - -[[package]] -name = "hex" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" - -[[package]] -name = "hex-conservative" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f" -dependencies = [ - "arrayvec", -] - -[[package]] -name = "hex-conservative" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830e599c2904b08f0834ee6337d8fe8f0ed4a63b5d9e7a7f49c0ffa06d08d360" -dependencies = [ - "arrayvec", -] - -[[package]] -name = "hex-conservative" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35431185f361ccf3ffc58254628af5f1f5d5f28531da2e02e5d6c82bbc282a10" -dependencies = [ - "arrayvec", -] - -[[package]] -name = "hex_lit" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd" - -[[package]] -name = "hkdf" -version = "0.12.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" -dependencies = [ - "hmac 0.12.1", -] - -[[package]] -name = "hkdf" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018" -dependencies = [ - "hmac 0.13.0", -] - -[[package]] -name = "hmac" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" -dependencies = [ - "digest 0.10.7", -] - -[[package]] -name = "hmac" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f" -dependencies = [ - "digest 0.11.3", -] - -[[package]] -name = "http" -version = "1.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8be7462df143984c4598a256ef469b251d7d7f9e271135073e78fc535414f3d0" -dependencies = [ - "bytes", - "itoa", -] - -[[package]] -name = "httparse" -version = "1.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" - -[[package]] -name = "hybrid-array" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da" -dependencies = [ - "serde", - "typenum", -] - -[[package]] -name = "iana-time-zone" -version = "0.1.65" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" -dependencies = [ - "android_system_properties", - "core-foundation-sys", - "iana-time-zone-haiku", - "js-sys", - "log", - "wasm-bindgen", - "windows-core", -] - -[[package]] -name = "iana-time-zone-haiku" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" -dependencies = [ - "cc", -] - -[[package]] -name = "icu_collections" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c" -dependencies = [ - "displaydoc", - "potential_utf", - "utf8_iter", - "yoke", - "zerofrom", - "zerovec", -] - -[[package]] -name = "icu_locale_core" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29" -dependencies = [ - "displaydoc", - "litemap", - "tinystr", - "writeable", - "zerovec", -] - -[[package]] -name = "icu_normalizer" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4" -dependencies = [ - "icu_collections", - "icu_normalizer_data", - "icu_properties", - "icu_provider", - "smallvec", - "zerovec", -] - -[[package]] -name = "icu_normalizer_data" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38" - -[[package]] -name = "icu_properties" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de" -dependencies = [ - "icu_collections", - "icu_locale_core", - "icu_properties_data", - "icu_provider", - "zerotrie", - "zerovec", -] - -[[package]] -name = "icu_properties_data" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14" - -[[package]] -name = "icu_provider" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421" -dependencies = [ - "displaydoc", - "icu_locale_core", - "writeable", - "yoke", - "zerofrom", - "zerotrie", - "zerovec", -] - -[[package]] -name = "idna" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" -dependencies = [ - "idna_adapter", - "smallvec", - "utf8_iter", -] - -[[package]] -name = "idna_adapter" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" -dependencies = [ - "icu_normalizer", - "icu_properties", -] - -[[package]] -name = "indexmap" -version = "2.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" -dependencies = [ - "equivalent", - "hashbrown 0.17.1", -] - -[[package]] -name = "inout" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" -dependencies = [ - "block-padding 0.3.3", - "generic-array 0.14.7", -] - -[[package]] -name = "inout" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7" -dependencies = [ - "block-padding 0.4.2", - "hybrid-array", -] - -[[package]] -name = "instant" -version = "0.1.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "itertools" -version = "0.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" - -[[package]] -name = "jobserver" -version = "0.1.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" -dependencies = [ - "getrandom 0.3.4", - "libc", -] - -[[package]] -name = "js-sys" -version = "0.3.99" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11" -dependencies = [ - "cfg-if", - "futures-util", - "once_cell", - "wasm-bindgen", -] - -[[package]] -name = "k256" -version = "0.13.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" -dependencies = [ - "cfg-if", - "ecdsa", - "elliptic-curve", - "once_cell", - "sha2 0.10.9", - "signature 2.2.0", -] - -[[package]] -name = "keccak" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653" -dependencies = [ - "cpufeatures 0.2.17", -] - -[[package]] -name = "keep-bitcoin" -version = "0.10.0" -source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" -dependencies = [ - "bitcoin", - "getrandom 0.4.3", - "hex", - "keep-core", - "miniscript", - "serde", - "serde_json", - "thiserror 2.0.21", - "tracing", - "zeroize", -] - -[[package]] -name = "keep-core" -version = "0.10.0" -source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" -dependencies = [ - "aes 0.9.3", - "argon2", - "base64 0.23.1", - "bech32 0.12.0", - "bincode", - "bip39", - "bitcoin", - "blake2", - "cbc 0.2.1", - "chacha20 0.10.2", - "chacha20poly1305 0.11.0", - "chrono", - "dirs", - "frost-secp256k1-tr", - "fs2", - "hex", - "hkdf 0.13.0", - "hmac 0.13.0", - "k256", - "memsec 0.7.0", - "memsecurity", - "rand 0.10.3", - "rand_core 0.6.4", - "redb 2.6.3", - "redb 4.1.0", - "scrypt 0.12.0", - "secrecy", - "serde", - "serde_json", - "sha2 0.10.9", - "sha2 0.11.0", - "subtle", - "thiserror 2.0.21", - "tracing", - "unicode-normalization", - "voprf", - "vsss-rs", - "zeroize", -] - -[[package]] -name = "keep-enclave-host" -version = "0.10.0" -source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" -dependencies = [ - "aes-gcm", - "base64 0.23.1", - "bincode", - "ciborium", - "const-oid 0.10.2", - "der 0.8.2", - "getrandom 0.4.3", - "hex", - "k256", - "keep-core", - "nix", - "p384", - "postcard", - "rand_core 0.10.1", - "redb 4.1.0", - "serde", - "serde_json", - "sha2 0.10.9", - "signature 3.0.0", - "thiserror 2.0.21", - "tracing", - "vsock", - "x509-cert", - "zeroize", -] - -[[package]] -name = "keep-frost-net" -version = "0.10.0" -source = "git+https://github.com/privkeyio/keep?rev=cdc47ddb120a50a2c31d7a2abd4279845c4dddd2#cdc47ddb120a50a2c31d7a2abd4279845c4dddd2" -dependencies = [ - "base64 0.23.1", - "bitcoin", - "frost-secp256k1-tr", - "fs2", - "hex", - "hmac 0.13.0", - "k256", - "keep-bitcoin", - "keep-core", - "keep-enclave-host", - "nostr-sdk", - "p256", - "parking_lot", - "rand 0.10.3", - "redb 4.1.0", - "rustls", - "rustls-pki-types", - "serde", - "serde_json", - "sha2 0.11.0", - "subtle", - "thiserror 2.0.21", - "tokio", - "tokio-rustls", - "tracing", - "url", - "webpki-roots 1.0.9", - "x509-cert", - "zeroize", -] - -[[package]] -name = "libc" -version = "0.2.186" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" - -[[package]] -name = "libredox" -version = "0.1.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f02ab6bace2054fb888a3c16f990117b579d14a3088e472d63c6011fa185c9d3" -dependencies = [ - "libc", -] - -[[package]] -name = "litemap" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0" - -[[package]] -name = "litrs" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092" - -[[package]] -name = "lock_api" -version = "0.4.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" -dependencies = [ - "scopeguard", -] - -[[package]] -name = "log" -version = "0.4.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5" - -[[package]] -name = "lru" -version = "0.16.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39" - -[[package]] -name = "memchr" -version = "2.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8" - -[[package]] -name = "memoffset" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" -dependencies = [ - "autocfg", -] - -[[package]] -name = "memsec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa0916b001582d253822171bd23f4a0229d32b9507fae236f5da8cad515ba7c" -dependencies = [ - "getrandom 0.2.17", - "libc", - "windows-sys 0.45.0", -] - -[[package]] -name = "memsec" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c797b9d6bb23aab2fc369c65f871be49214f5c759af65bde26ffaaa2b646b492" -dependencies = [ - "getrandom 0.2.17", - "libc", - "windows-sys 0.45.0", -] - -[[package]] -name = "memsecurity" -version = "3.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d5926560aa18d0a437ef884b5f18a61507c00c7268e1faaf6a6e288d89a3675" -dependencies = [ - "arrayvec", - "ascon-aead", - "blake3", - "borsh", - "bytes", - "memsec 0.6.3", - "once_cell", - "rand_chacha 0.3.1", - "rand_core 0.6.4", - "zeroize", -] - -[[package]] -name = "miniscript" -version = "13.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd35e2c377504e50159561884b03610711db6c2fec6c89f2b98d94016684726b" -dependencies = [ - "bech32 0.11.1", - "bitcoin", - "hex-conservative 1.2.0", -] - -[[package]] -name = "mio" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02bd0af71c67b473010cbbc60715ee815645a4dc942899111f494b4b737d6fda" -dependencies = [ - "libc", - "wasi", - "windows-sys 0.61.2", -] - -[[package]] -name = "multiexp" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ec2ce93a6f06ac6cae04c1da3f2a6a24fcfc1f0eb0b4e0f3d302f0df45326cb" -dependencies = [ - "ff", - "group", - "rand_core 0.6.4", - "rustversion", - "std-shims", - "zeroize", -] - -[[package]] -name = "negentropy" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0efe882e02d206d8d279c20eb40e03baf7cb5136a1476dc084a324fbc3ec42d" - -[[package]] -name = "nix" -version = "0.31.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" -dependencies = [ - "bitflags", - "cfg-if", - "cfg_aliases", - "libc", - "memoffset", -] - -[[package]] -name = "nostr" -version = "0.44.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7d3d987ea7078dc36947cde532637c472a229426702e4331dd7667325378bd9" -dependencies = [ - "aes 0.8.4", - "base64 0.22.1", - "bech32 0.11.1", - "bip39", - "bitcoin_hashes", - "cbc 0.1.2", - "chacha20 0.9.1", - "chacha20poly1305 0.10.1", - "getrandom 0.2.17", - "hex", - "instant", - "scrypt 0.11.0", - "secp256k1", - "serde", - "serde_json", - "unicode-normalization", - "url", -] - -[[package]] -name = "nostr-database" -version = "0.44.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7462c9d8ae5ef6a28d66a192d399ad2530f1f2130b13186296dbb11bdef5b3d1" -dependencies = [ - "lru", - "nostr", - "tokio", -] - -[[package]] -name = "nostr-gossip" -version = "0.44.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ade30de16869618919c6b5efc8258f47b654a98b51541eb77f85e8ec5e3c83a6" -dependencies = [ - "nostr", -] - -[[package]] -name = "nostr-relay-builder" -version = "0.44.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08ed09e8363503c6f464087b530a1f43cf68be6292bd4928b5ea1141b03dc11c" -dependencies = [ - "async-utility", - "async-wsocket", - "atomic-destructor", - "hex", - "negentropy", - "nostr", - "nostr-database", - "tokio", - "tracing", -] - -[[package]] -name = "nostr-relay-pool" -version = "0.44.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c85c54d6ca9aae4ae2bf19a7663ba9db5f45f783f1d24aff55f006386b8b99a1" -dependencies = [ - "async-utility", - "async-wsocket", - "atomic-destructor", - "hex", - "lru", - "negentropy", - "nostr", - "nostr-database", - "tokio", - "tracing", -] - -[[package]] -name = "nostr-sdk" -version = "0.44.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "471732576710e779b64f04c55e3f8b5292f865fea228436daf19694f0bf70393" -dependencies = [ - "async-utility", - "nostr", - "nostr-database", - "nostr-gossip", - "nostr-relay-pool", - "tokio", - "tracing", -] - -[[package]] -name = "num" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23" -dependencies = [ - "num-bigint", - "num-complex", - "num-integer", - "num-iter", - "num-rational", - "num-traits", -] - -[[package]] -name = "num-bigint" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" -dependencies = [ - "num-integer", - "num-traits", - "rand 0.8.6", - "serde", -] - -[[package]] -name = "num-complex" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495" -dependencies = [ - "num-traits", - "rand 0.8.6", - "serde", -] - -[[package]] -name = "num-integer" -version = "0.1.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" -dependencies = [ - "num-traits", -] - -[[package]] -name = "num-iter" -version = "0.1.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", -] - -[[package]] -name = "num-rational" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824" -dependencies = [ - "num-bigint", - "num-integer", - "num-traits", - "serde", -] - -[[package]] -name = "num-traits" -version = "0.2.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" -dependencies = [ - "autocfg", -] - -[[package]] -name = "once_cell" -version = "1.21.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" - -[[package]] -name = "opaque-debug" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" - -[[package]] -name = "option-ext" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" - -[[package]] -name = "p256" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" -dependencies = [ - "ecdsa", - "elliptic-curve", - "primeorder", - "sha2 0.10.9", -] - -[[package]] -name = "p384" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6" -dependencies = [ - "ecdsa", - "elliptic-curve", - "primeorder", - "sha2 0.10.9", -] - -[[package]] -name = "parking_lot" -version = "0.12.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" -dependencies = [ - "lock_api", - "parking_lot_core", -] - -[[package]] -name = "parking_lot_core" -version = "0.9.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" -dependencies = [ - "cfg-if", - "libc", - "redox_syscall", - "smallvec", - "windows-link", -] - -[[package]] -name = "password-hash" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166" -dependencies = [ - "base64ct", - "rand_core 0.6.4", - "subtle", -] - -[[package]] -name = "pbkdf2" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" -dependencies = [ - "digest 0.10.7", - "hmac 0.12.1", -] - -[[package]] -name = "pbkdf2" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629" -dependencies = [ - "digest 0.11.3", - "hmac 0.13.0", -] - -[[package]] -name = "pem-rfc7468" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412" -dependencies = [ - "base64ct", -] - -[[package]] -name = "pem-rfc7468" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9" -dependencies = [ - "base64ct", -] - -[[package]] -name = "percent-encoding" -version = "2.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" - -[[package]] -name = "pin-project-lite" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" - -[[package]] -name = "pkcs8" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" -dependencies = [ - "der 0.7.10", - "spki 0.7.3", -] - -[[package]] -name = "pkg-config" -version = "0.3.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" - -[[package]] -name = "poly1305" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf" -dependencies = [ - "cpufeatures 0.2.17", - "opaque-debug", - "universal-hash 0.5.1", -] - -[[package]] -name = "poly1305" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a00baa632505d05512f48a963e16051c54fda9a95cc9acea1a4e3c90991c4a2e" -dependencies = [ - "cpufeatures 0.3.0", - "universal-hash 0.6.1", -] - -[[package]] -name = "polyval" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede" -dependencies = [ - "cpubits", - "cpufeatures 0.3.0", - "universal-hash 0.6.1", -] - -[[package]] -name = "postcard" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24" -dependencies = [ - "cobs", - "embedded-io 0.4.0", - "embedded-io 0.6.1", - "heapless 0.7.17", - "serde", -] - -[[package]] -name = "potential_utf" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564" -dependencies = [ - "zerovec", -] - -[[package]] -name = "ppv-lite86" -version = "0.2.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" -dependencies = [ - "zerocopy", -] - -[[package]] -name = "primeorder" -version = "0.13.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" -dependencies = [ - "elliptic-curve", -] - -[[package]] -name = "proc-macro-crate" -version = "3.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f" -dependencies = [ - "toml_edit", -] - -[[package]] -name = "proc-macro2" -version = "1.0.106" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "quote" -version = "1.0.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "r-efi" -version = "5.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" - -[[package]] -name = "r-efi" -version = "6.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" - -[[package]] -name = "radium" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" - -[[package]] -name = "rand" -version = "0.8.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a" -dependencies = [ - "libc", - "rand_chacha 0.3.1", - "rand_core 0.6.4", -] - -[[package]] -name = "rand" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" -dependencies = [ - "rand_chacha 0.9.0", - "rand_core 0.9.5", -] - -[[package]] -name = "rand" -version = "0.10.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" -dependencies = [ - "chacha20 0.10.2", - "getrandom 0.4.3", - "rand_core 0.10.1", -] - -[[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 0.6.4", -] - -[[package]] -name = "rand_chacha" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" -dependencies = [ - "ppv-lite86", - "rand_core 0.9.5", -] - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom 0.2.17", -] - -[[package]] -name = "rand_core" -version = "0.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" -dependencies = [ - "getrandom 0.3.4", -] - -[[package]] -name = "rand_core" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" - -[[package]] -name = "redb" -version = "2.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eca1e9d98d5a7e9002d0013e18d5a9b000aee942eb134883a82f06ebffb6c01" -dependencies = [ - "libc", -] - -[[package]] -name = "redb" -version = "4.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e925444704b5f17d32bf42f5b6e2df050bceebc3dcd6e71cc73dafe8092e839" -dependencies = [ - "libc", -] - -[[package]] -name = "redox_syscall" -version = "0.5.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" -dependencies = [ - "bitflags", -] - -[[package]] -name = "redox_users" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" -dependencies = [ - "getrandom 0.2.17", - "libredox", - "thiserror 2.0.21", -] - -[[package]] -name = "rfc6979" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" -dependencies = [ - "hmac 0.12.1", - "subtle", -] - -[[package]] -name = "ring" -version = "0.17.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" -dependencies = [ - "cc", - "cfg-if", - "getrandom 0.2.17", - "libc", - "untrusted", - "windows-sys 0.52.0", -] - -[[package]] -name = "rustc_version" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" -dependencies = [ - "semver", -] - -[[package]] -name = "rustls" -version = "0.23.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634" -dependencies = [ - "aws-lc-rs", - "log", - "once_cell", - "ring", - "rustls-pki-types", - "rustls-webpki", - "subtle", - "zeroize", -] - -[[package]] -name = "rustls-pki-types" -version = "1.15.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" -dependencies = [ - "zeroize", -] - -[[package]] -name = "rustls-webpki" -version = "0.103.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" -dependencies = [ - "aws-lc-rs", - "ring", - "rustls-pki-types", - "untrusted", -] - -[[package]] -name = "rustversion" -version = "1.0.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" - -[[package]] -name = "salsa20" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213" -dependencies = [ - "cipher 0.4.4", -] - -[[package]] -name = "salsa20" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f874456e72520ff1375a06c588eaf074b0f01f9e9e1aada45bd9b7954a6e42c" -dependencies = [ - "cfg-if", - "cipher 0.5.2", -] - -[[package]] -name = "scopeguard" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" - -[[package]] -name = "scrypt" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f" -dependencies = [ - "password-hash", - "pbkdf2 0.12.2", - "salsa20 0.10.2", - "sha2 0.10.9", -] - -[[package]] -name = "scrypt" -version = "0.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d87af57419b594aa23fa95f09f0e06d80d84ba01c26148c43844cad6ff4485f0" -dependencies = [ - "cfg-if", - "pbkdf2 0.13.0", - "salsa20 0.11.0", - "sha2 0.11.0", -] - -[[package]] -name = "sec1" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" -dependencies = [ - "base16ct", - "der 0.7.10", - "generic-array 0.14.7", - "pkcs8", - "subtle", - "zeroize", -] - -[[package]] -name = "secp256k1" -version = "0.29.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113" -dependencies = [ - "bitcoin_hashes", - "rand 0.8.6", - "secp256k1-sys", - "serde", -] - -[[package]] -name = "secp256k1-sys" -version = "0.10.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9" -dependencies = [ - "cc", -] - -[[package]] -name = "secrecy" -version = "0.10.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e891af845473308773346dc847b2c23ee78fe442e0472ac50e22a18a93d3ae5a" -dependencies = [ - "zeroize", -] - -[[package]] -name = "semver" -version = "1.0.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" - -[[package]] -name = "serde" -version = "1.0.229" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" -dependencies = [ - "serde_core", - "serde_derive", -] - -[[package]] -name = "serde_core" -version = "1.0.229" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.229" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" -dependencies = [ - "proc-macro2", - "quote", - "syn 3.0.0", -] - -[[package]] -name = "serde_json" -version = "1.0.151" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" -dependencies = [ - "itoa", - "memchr", - "serde", - "serde_core", - "zmij", -] - -[[package]] -name = "serdect" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177" -dependencies = [ - "base16ct", - "serde", -] - -[[package]] -name = "serdect" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f42f67da2385b51a5f9652db9c93d78aeaf7610bf5ec366080b6de810604af53" -dependencies = [ - "base16ct", - "serde", -] - -[[package]] -name = "sha1" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" -dependencies = [ - "cfg-if", - "cpufeatures 0.2.17", - "digest 0.10.7", -] - -[[package]] -name = "sha1" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214" -dependencies = [ - "cfg-if", - "cpufeatures 0.3.0", - "digest 0.11.3", -] - -[[package]] -name = "sha2" -version = "0.10.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" -dependencies = [ - "cfg-if", - "cpufeatures 0.2.17", - "digest 0.10.7", -] - -[[package]] -name = "sha2" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" -dependencies = [ - "cfg-if", - "cpufeatures 0.3.0", - "digest 0.11.3", -] - -[[package]] -name = "sha3" -version = "0.10.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874" -dependencies = [ - "digest 0.10.7", - "keccak", -] - -[[package]] -name = "shlex" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" - -[[package]] -name = "signal-hook-registry" -version = "1.4.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" -dependencies = [ - "errno", - "libc", -] - -[[package]] -name = "signature" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" -dependencies = [ - "digest 0.10.7", - "rand_core 0.6.4", -] - -[[package]] -name = "signature" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5" -dependencies = [ - "rand_core 0.10.1", -] - -[[package]] -name = "slab" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" - -[[package]] -name = "smallvec" -version = "1.15.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" - -[[package]] -name = "socket2" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52d1cfed4120b4d927bf7c0f86d2087a4a7d6027c906d9f9d525a80573b9be51" -dependencies = [ - "libc", - "windows-sys 0.61.2", -] - -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" -dependencies = [ - "lock_api", -] - -[[package]] -name = "spin" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5fe4ccb98d9c292d56fec89a5e07da7fc4cf0dc11e156b41793132775d3e591" - -[[package]] -name = "spki" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" -dependencies = [ - "base64ct", - "der 0.7.10", -] - -[[package]] -name = "spki" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d9efca8738c78ee9484207732f728b1ef517bbb1833d6fc0879ca898a522f6f" -dependencies = [ - "base64ct", - "der 0.8.2", -] - -[[package]] -name = "stable_deref_trait" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" - -[[package]] -name = "std-shims" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "227c4f8561598188d0df96dbe749824576174bba278b5b6bb2eacff1066067d0" -dependencies = [ - "hashbrown 0.16.1", - "rustversion", - "spin 0.10.0", -] - -[[package]] -name = "subtle" -version = "2.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" - -[[package]] -name = "syn" -version = "2.0.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2fac314a64dc9a36e61a9eb4261a5e9bbfbc922b27e518af97bc32b926cf967" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "synstructure" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "tap" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" - -[[package]] -name = "thiserror" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" -dependencies = [ - "thiserror-impl 1.0.69", -] - -[[package]] -name = "thiserror" -version = "2.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" -dependencies = [ - "thiserror-impl 2.0.21", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "thiserror-impl" -version = "2.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" -dependencies = [ - "proc-macro2", - "quote", - "syn 3.0.0", -] - -[[package]] -name = "tinystr" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d" -dependencies = [ - "displaydoc", - "zerovec", -] - -[[package]] -name = "tinyvec" -version = "1.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - -[[package]] -name = "tls_codec" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0de2e01245e2bb89d6f05801c564fa27624dbd7b1846859876c7dad82e90bf6b" -dependencies = [ - "tls_codec_derive", - "zeroize", -] - -[[package]] -name = "tls_codec_derive" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "tokio" -version = "1.53.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044" -dependencies = [ - "bytes", - "libc", - "mio", - "parking_lot", - "pin-project-lite", - "signal-hook-registry", - "socket2", - "tokio-macros", - "windows-sys 0.61.2", -] - -[[package]] -name = "tokio-macros" -version = "2.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "tokio-rustls" -version = "0.26.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c9cc2678c2cdd569ef8215e2afd7954ada2ae20b4fdd2c5fe6139a3b02d105db" -dependencies = [ - "rustls", - "tokio", -] - -[[package]] -name = "tokio-socks" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7e2948f60dbe26b35f2c7fb74ac2854c1fddded0fe9d7548fcc674a246f7615" -dependencies = [ - "either", - "futures-util", - "thiserror 1.0.69", - "tokio", -] - -[[package]] -name = "tokio-tungstenite" -version = "0.26.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" -dependencies = [ - "futures-util", - "log", - "rustls", - "rustls-pki-types", - "tokio", - "tokio-rustls", - "tungstenite", - "webpki-roots 0.26.11", -] - -[[package]] -name = "toml_datetime" -version = "1.1.1+spec-1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7" -dependencies = [ - "serde_core", -] - -[[package]] -name = "toml_edit" -version = "0.25.12+spec-1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2153edc6955a6c354fad8f5efd38b6a8769bdccf9fe50f8e1329f81b0baa5d7" -dependencies = [ - "indexmap", - "toml_datetime", - "toml_parser", - "winnow", -] - -[[package]] -name = "toml_parser" -version = "1.1.3+spec-1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56" -dependencies = [ - "winnow", -] - -[[package]] -name = "tracing" -version = "0.1.44" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" -dependencies = [ - "pin-project-lite", - "tracing-attributes", - "tracing-core", -] - -[[package]] -name = "tracing-attributes" -version = "0.1.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "tracing-core" -version = "0.1.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" -dependencies = [ - "once_cell", -] - -[[package]] -name = "tungstenite" -version = "0.26.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13" -dependencies = [ - "bytes", - "data-encoding", - "http", - "httparse", - "log", - "rand 0.9.4", - "rustls", - "rustls-pki-types", - "sha1 0.10.6", - "thiserror 2.0.21", - "utf-8", -] - -[[package]] -name = "typenum" -version = "1.20.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" - -[[package]] -name = "unicode-ident" -version = "1.0.24" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" - -[[package]] -name = "unicode-normalization" -version = "0.1.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8" -dependencies = [ - "tinyvec", -] - -[[package]] -name = "universal-hash" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" -dependencies = [ - "crypto-common 0.1.7", - "subtle", -] - -[[package]] -name = "universal-hash" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96" -dependencies = [ - "crypto-common 0.2.2", - "ctutils", -] - -[[package]] -name = "untrusted" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" - -[[package]] -name = "url" -version = "2.5.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" -dependencies = [ - "form_urlencoded", - "idna", - "percent-encoding", - "serde", - "serde_derive", -] - -[[package]] -name = "utf-8" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" - -[[package]] -name = "utf8_iter" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" - -[[package]] -name = "version_check" -version = "0.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" - -[[package]] -name = "visibility" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d674d135b4a8c1d7e813e2f8d1c9a58308aee4a680323066025e53132218bd91" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "voprf" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28f59c30c76e2fea54cdece6a054e2662feffa7ab19658a7887524265ee39470" -dependencies = [ - "curve25519-dalek", - "derive-where", - "digest 0.10.7", - "displaydoc", - "elliptic-curve", - "generic-array 0.14.7", - "rand_core 0.6.4", - "serde", - "sha2 0.10.9", - "subtle", - "zeroize", -] - -[[package]] -name = "vsock" -version = "0.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ba782755fc073877e567c2253c0be48e4aa9a254c232d36d3985dfae0bd5205" -dependencies = [ - "libc", - "nix", -] - -[[package]] -name = "vsss-rs" -version = "5.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ec751bdcc8bda099e269b24cc6b4ad14f9ce8b0490c1599174070e792ecd70c" -dependencies = [ - "crypto-bigint 0.5.5", - "crypto-bigint 0.6.1", - "elliptic-curve", - "elliptic-curve-tools", - "generic-array 1.4.3", - "hex", - "hybrid-array", - "num", - "rand_core 0.6.4", - "serde", - "sha3", - "subtle", - "zeroize", -] - -[[package]] -name = "wasi" -version = "0.11.1+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" - -[[package]] -name = "wasip2" -version = "1.0.3+wasi-0.2.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" -dependencies = [ - "wit-bindgen", -] - -[[package]] -name = "wasm-bindgen" -version = "0.2.122" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409" -dependencies = [ - "cfg-if", - "once_cell", - "rustversion", - "wasm-bindgen-macro", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.72" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9473dbd2991ae90b6291c3c32c30c6187ac49aa32f9905d1cce280ec1e110b0f" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.122" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.122" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e" -dependencies = [ - "bumpalo", - "proc-macro2", - "quote", - "syn 2.0.117", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.122" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "web-sys" -version = "0.3.99" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d621441cfc37b84979402712047321980c178f299193a3589d05b99e8763436" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "webpki-roots" -version = "0.26.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" -dependencies = [ - "webpki-roots 1.0.9", -] - -[[package]] -name = "webpki-roots" -version = "1.0.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a" -dependencies = [ - "rustls-pki-types", -] - -[[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-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-core" -version = "0.58.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99" -dependencies = [ - "windows-implement", - "windows-interface", - "windows-result", - "windows-strings", - "windows-targets 0.52.6", -] - -[[package]] -name = "windows-implement" -version = "0.58.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "windows-interface" -version = "0.58.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "windows-link" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" - -[[package]] -name = "windows-result" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e" -dependencies = [ - "windows-targets 0.52.6", -] - -[[package]] -name = "windows-strings" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10" -dependencies = [ - "windows-result", - "windows-targets 0.52.6", -] - -[[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.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets 0.52.6", -] - -[[package]] -name = "windows-sys" -version = "0.61.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" -dependencies = [ - "windows-link", -] - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" -dependencies = [ - "windows_aarch64_gnullvm 0.52.6", - "windows_aarch64_msvc 0.52.6", - "windows_i686_gnu 0.52.6", - "windows_i686_gnullvm", - "windows_i686_msvc 0.52.6", - "windows_x86_64_gnu 0.52.6", - "windows_x86_64_gnullvm 0.52.6", - "windows_x86_64_msvc 0.52.6", -] - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" - -[[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.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" - -[[package]] -name = "winnow" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1" -dependencies = [ - "memchr", -] - -[[package]] -name = "wit-bindgen" -version = "0.57.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" - -[[package]] -name = "writeable" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" - -[[package]] -name = "wyz" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" -dependencies = [ - "tap", -] - -[[package]] -name = "x509-cert" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "105ef4642d9cb137ef83d623d0e4bf08b8adf69e9918ca904a174adb6d3d038b" -dependencies = [ - "const-oid 0.10.2", - "der 0.8.2", - "sha1 0.11.0", - "signature 3.0.0", - "spki 0.8.0", - "tls_codec", -] - -[[package]] -name = "yoke" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca" -dependencies = [ - "stable_deref_trait", - "yoke-derive", - "zerofrom", -] - -[[package]] -name = "yoke-derive" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", - "synstructure", -] - -[[package]] -name = "zerocopy" -version = "0.8.50" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b065d4f0e55f82fae73202e189638116a87c55ab6b8e6c2721e13dd9d854ad1" -dependencies = [ - "zerocopy-derive", -] - -[[package]] -name = "zerocopy-derive" -version = "0.8.50" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b631b19d36a892ab55420c92dbc83ccd79274f25be714855d3074aa71cab639" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "zerofrom" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" -dependencies = [ - "zerofrom-derive", -] - -[[package]] -name = "zerofrom-derive" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", - "synstructure", -] - -[[package]] -name = "zeroize" -version = "1.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" -dependencies = [ - "zeroize_derive", -] - -[[package]] -name = "zeroize_derive" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "zerotrie" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf" -dependencies = [ - "displaydoc", - "yoke", - "zerofrom", -] - -[[package]] -name = "zerovec" -version = "0.11.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239" -dependencies = [ - "yoke", - "zerofrom", - "zerovec-derive", -] - -[[package]] -name = "zerovec-derive" -version = "0.11.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.117", -] - -[[package]] -name = "zmij" -version = "1.0.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/components/frost_tr/rust/vectors/kfp.json b/components/frost_tr/rust/vectors/kfp.json index 297a75d..de89d0f 100644 --- a/components/frost_tr/rust/vectors/kfp.json +++ b/components/frost_tr/rust/vectors/kfp.json @@ -1997,5 +1997,5 @@ "threshold": 2 } ], - "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (vectors/gen-kfp)" + "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (test/vectors/gen-kfp)" } diff --git a/test/vectors/gen-kfp/.gitignore b/test/vectors/gen-kfp/.gitignore new file mode 100644 index 0000000..2c96eb1 --- /dev/null +++ b/test/vectors/gen-kfp/.gitignore @@ -0,0 +1,2 @@ +target/ +Cargo.lock diff --git a/components/frost_tr/rust/vectors/gen-kfp/Cargo.toml b/test/vectors/gen-kfp/Cargo.toml similarity index 100% rename from components/frost_tr/rust/vectors/gen-kfp/Cargo.toml rename to test/vectors/gen-kfp/Cargo.toml diff --git a/components/frost_tr/rust/vectors/gen-kfp/src/main.rs b/test/vectors/gen-kfp/src/main.rs similarity index 95% rename from components/frost_tr/rust/vectors/gen-kfp/src/main.rs rename to test/vectors/gen-kfp/src/main.rs index fb1fe0f..aca98db 100644 --- a/components/frost_tr/rust/vectors/gen-kfp/src/main.rs +++ b/test/vectors/gen-kfp/src/main.rs @@ -6,9 +6,12 @@ //! nostr crate keep uses): transport keys, announce proofs and the announces a //! running keep node publishes, rendezvous addresses, NIP-44 v2 payloads, keep //! events sealed to a member, NIP-01 serializations and salted session ids. -//! Groups come from keep's dealer, so each run writes a fresh, equally valid set: +//! Groups come from keep's dealer, so each run writes a fresh, equally valid set. +//! The lockfile is not tracked (the RNG hygiene check bans getrandom in any); +//! seed it from keep's at the pinned commit, which resolves under keep's MSRV: //! -//! cargo run --release > ../kfp.json +//! git -C show cdc47ddb120a50a2c31d7a2abd4279845c4dddd2:Cargo.lock > Cargo.lock +//! cargo run --release > ../../../components/frost_tr/rust/vectors/kfp.json use std::time::Duration; use keep_core::frost::{ThresholdConfig, TrustedDealer}; @@ -189,7 +192,7 @@ async fn main() { println!( "{}", serde_json::to_string_pretty(&json!({ - "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (vectors/gen-kfp)", + "source": "keep-core/keep-frost-net cdc47ddb and nostr 0.44.7 (test/vectors/gen-kfp)", "groups": groups, "serializations": serializations, "sessions": sessions,