diff --git a/components/frost_tr/include/frost_tr.h b/components/frost_tr/include/frost_tr.h index 8b6c039..40e4b0c 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,53 @@ 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. As for +// every function here, no output buffer may overlap an input; seal and open +// 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]); + +// 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. +// 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, 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); + +// 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 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]); + +// 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..107e6c4 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,28 @@ 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", + "zeroize", +] + [[package]] name = "cobs" version = "0.3.0" @@ -124,7 +161,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer", + "const-oid", "crypto-common", + "subtle", ] [[package]] @@ -136,6 +175,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 +286,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 +351,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 +400,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" dependencies = [ "cfg-if", + "ecdsa", "elliptic-curve", + "sha2", + "signature", ] [[package]] @@ -488,6 +574,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..b76772b 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, features = ["zeroize"] } +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..a91f630 --- /dev/null +++ b/components/frost_tr/rust/src/kfp.rs @@ -0,0 +1,390 @@ +// 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, E_SELFCHECK}; + +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; + +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: 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)?; + 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(); + 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(&message, aux).map_err(|_| E_KEY)?; + // 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()) +} + +/// 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 (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) +} + +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) +} + +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 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], out: &mut [u8]) -> Result { + let mut nonce = [0u8; 32]; + DeviceRng.fill_bytes(&mut nonce); + seal_with_nonce(kp, recipient, plaintext, &nonce, out) +} + +/// 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 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 conversation = conversation_key(&transport_secret(kp)?, sender)?; + let keys = MessageKeys::new(&conversation, &nonce)?; + 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); + } + 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]`) +/// 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); + 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())) +} + +/// 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, 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()); + } + 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 + }; + 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!(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 1f20a2c..7259abf 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,191 @@ 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)?) +} + +/// 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() || overlaps(plaintext.as_ptr(), plaintext.len(), out, cap) { + return signer::E_NULL; + } + 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. 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. +#[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() || overlaps(payload.as_ptr(), payload.len(), out, cap) { + return signer::E_NULL; + } + 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]`) +/// 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_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 }; + *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 { + 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 }; + 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 +793,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 +1024,279 @@ 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"]); + 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 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_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(); + } + } + } + + /// 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 ts = content["timestamp"].as_u64().unwrap(); + 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(); + 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 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}"); + 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"); + // 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); + 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()); + } + 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. + #[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_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"]; + 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..de89d0f --- /dev/null +++ b/components/frost_tr/rust/vectors/kfp.json @@ -0,0 +1,2001 @@ +{ + "groups": [ + { + "group_key": "028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a", + "key_packages": [ + "00230f8ab300000000000000000000000000000000000000000000000000000000000000018dd0747b75a6a8b7e4791eddfd02634dd9427e699fa41ab3f081e10c1bfdf568032a46eee8e7b130764621aaedd0bc7d7f3789736901a29b6cdf7f2324dd16ad25028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000002cea4ef8e0156fb1223576815309fc4dc6218b0bba5a80d1067cd00a6fe69357303b6bfacc7235ecc2e5983f10ddc72c5f8d9f9ce753dc8fc8c5354457891c89222028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000030f796aa08d074d6c6235b14c643d266c30400626fc635f311f45c1b5109e343d020c9673e17005783e1374f60be641ebe5fdf3883a009c49b8aa337fd9e3c15457028256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a02" + ], + "members": [ + { + "announce": { + "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": "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad", + "sig": "af866e6e994d2551bea59068b9b290b4b6ee208b381c154595d824303f29b47a66eb52625853406301465b34834c68cc012ad02c96c0a7398060df92508cf944", + "tags": [ + [ + "g", + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" + ], + [ + "t", + "announce" + ], + [ + "p", + "9abc59a7bd6951a409d383d0d59dfcd8185b45b2e07b06dfab536de847397f82" + ], + [ + "p", + "c579c4bda2e29644907a238471ac5ea5b96c976427a0d39e4c3af9a1c30377c0" + ] + ] + }, + "events": [ + { + "event": { + "content": "AlFDv6gjLY2za8JzP19i2McRxGWn+zIwjWvx8DGjFWbTsrQlly3J9iIdOpQhmT6ozVzgNuZQnLEzh9+/iH+6si2qkGWwuqh7CwlhwUTfUUmI9Dvwnkahoh8yVqV5TyyeKJJ7aItvsER8fUul6qOyx9yj8skSf5puiMTwgmKzXiMNq2ZGtzPwKc1uS5lr8iRNKIyhG7CpIRxoFLYS6kJFRFKx0u8BxKDvzn9IYLYGYaYfHGnERL+/4fpOr5W27e2QaZUC", + "created_at": 1791467344, + "id": "11c74924322701d01849e3ec383b0685cfac37dcd0e7bc8d98c90117a37b1bbb", + "kind": 24242, + "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "sig": "4d9cd0ce394ac3b4bd51f0ad99cadc24a36500aa4187dd5f294fff0abbf87df25f1d108e570aed6ce15e59e3fc1ad6c04efaf37a1495622f54bb529ddfbfddef", + "tags": [ + [ + "p", + "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467348}" + }, + { + "event": { + "content": "Ao+vsUYC55Q+/Ya++v+4JAJZemVpQxo+So0F+OsLCu3iSib0AWlOfPZTk8o1DDBjaxD1TB9CcSXg5eAI7BH87R1rFH/Oto0EZ1xQ6SvmuWBQx/9gDUypwKaXh3rmSknwiM6oUSATU6MMSTiD/0ZmCjv1URx0MFaIlS0y9HCmAKzmwTI3nHM/drkz4C25ZEnMYaH0CMCVRFxQzyRsm63G5wefiTbxlQnP7lyiorgWiTMhaIaJnVFo+ZxHENVTh/Lb2VW5", + "created_at": 1791467344, + "id": "d347417d29df34c9622dcf6c8b22627deb98f9fd2b2b4a1e70bdc2eb209ad68f", + "kind": 24242, + "pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "sig": "7feb3d796370b4b5a12aeeaa61420f60092b2f0d38295f28281b9a2ad8afa111f916c7dc86a8aa274e813598fbc44e7e3d84e9b9a7ca2af2f6967406c67ade87", + "tags": [ + [ + "p", + "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"dfff7552e7a7eea973869e2daaf025c9c4d3977d24b26b64055df2a0fd101b66\",\"timestamp\":1791467348}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "dcf6b6cd32390e97181bf43af7076a3181a82d786504e4ac6531a728c38fbe79", + "payload": "Atz2ts0yOQ6XGBv0OvcHajGBqC14ZQTkrGUxpyjDj75552NjOYHJR6G7qkc90KSbbc5Bwa18Kz+XFrJe6SjctU8kdBLNCYQC/pN2r9RGeHwOEPxP0ppO2lX5jzJNcitEO0s8" + }, + { + "length": 16, + "nonce": "48b4b62ce54ec726d14721fa33ea2e6f5ba7b440cd8a312ee7ed8dc97317cd78", + "payload": "Aki0tizlTscm0Uch+jPqLm9bp7RAzYoxLuftjclzF814hnHsjn5+vvSqf6E9nWjmyGHvcJarTHXhdhpkW5M/0TtfPBYmYJhbBm4bCK5/HBUjir7k+1M6xwhiZLQBm7KvxHzT" + }, + { + "length": 31, + "nonce": "9ab333ac2c99fb5751f88175a1bc5e9f58d8c81aa2d058ef89c56fb9c0ec4759", + "payload": "ApqzM6wsmftXUfiBdaG8Xp9Y2MgaotBY74nFb7nA7EdZsJEK9wz5ae3kJvblEG2b0Qs6fHYhs65kPom7RSmSI35ITCNlz7O3SiPeSgR6g7w8OGrgdczBSVIQ1eFflDK36wAt" + }, + { + "length": 32, + "nonce": "6a587cd0a7f9aa7b9eeabb7a7afaec753d742de3aab2a641c6759cf1c4063e01", + "payload": "AmpYfNCn+ap7nuq7enr67HU9dC3jqrKmQcZ1nPHEBj4BzQdC2vaYW93KhGzilr7b+aKPeK8nf5gNynQq3ZfIYTwayMuZQGIa8inKXTeGK3YVXX6xCQSoWEvVjVRRgWUMsvg/" + }, + { + "length": 33, + "nonce": "a7022876b07e89c5ac6df59a36ce873bce8717cdbc5d3b9e2be89ab31db1411e", + "payload": "AqcCKHawfonFrG31mjbOhzvOhxfNvF07nivomrMdsUEebJEq6IXvvfjevAxxGg9wowkiLjNolSUhEYa851QN6UbcRY4vSxaBBpowQxCiiPLBczu2Hyjd+Kcc6y6Q+bLQUqS/qPS3uytPVKefwcH6A+b54KePSHSLHd2V7GgRRGVP+18=" + }, + { + "length": 64, + "nonce": "1e18c24039c7407aceed930c4bcbbffe4482506fa0980919601b035c237f6692", + "payload": "Ah4YwkA5x0B6zu2TDEvLv/5EglBvoJgJGWAbA1wjf2aSNBqpORrteQrnIANTi7qlJslQe06qHovTEej8u94vdFKOsgYo1NuG60FKp5vPyXuaNJraOeCxPqIQEflCvH3V1gao/GPy2xKpVZ/GjC0yNQErHhnssSYYTqtFNOsHdndyJ0c=" + }, + { + "length": 65, + "nonce": "23e76330d01ad81fa02cc808b8b7898bbf56bcbdea77538c17a634f00909c7ef", + "payload": "AiPnYzDQGtgfoCzICLi3iYu/Vry96ndTjBemNPAJCcfvMfV/Kt28w3tHDBCFal7OpTgld1fVt1pjtXwp6WXIgkPcM9p2QstaXOO/JaAelAG6X2Ty+U+0oE56jQ6dkhQeZDCbbN1DbznWHGjJNSTDvpMHL7vPxThpj7I7RalDUZ2iOOsptg+HwMnkGMXr8eVg3pyXdtD8qHnUGJEL0jtPDf0Xxg==" + }, + { + "length": 255, + "nonce": "a45a569d10dbdbc16a553ec39e7d57c7ae373d5743e4575c939b7af6286194c3", + "payload": "AqRaVp0Q29vBalU+w559V8euNz1XQ+RXXJObevYoYZTDakmGM4COlH+LgLlbYajSTuab3ewTUzkdOZixLHFYQadTf0PfJ+fv/PFfKCkMFsPqyVzfqmZDhMr7nIu3GOiF9P8KEOP/iki00HUjWY9mG7LLWHI54vpzl7EX5ef36SqwEupFf58/CZ0ZHWFfN8s9wxf4Q6MQbbBacEYOUU/tWbkJZT8xM/NR7znBInQ2mX0dDUQnJ9e27y8Kj4mx2neXIVZQ7mrPtbYD1WS7tZd4udxAaohGgdE2/IFd4kGtx21ieRotOaD8jMyvM1cM1pKx2UIm/QbTrGccKBWnnF5d6wY7SDAvnpaJgAYgutdJQQ2w6CV11ejc1aE4JXFoCa2tRmBRxuPYpq+lqaHlCVNFbYzXLX17qFxRhFhWhgBpkWHEmvs=" + }, + { + "length": 256, + "nonce": "7a57603ffceeac0e818711589991e97122d189d97482f8ac65f5419b3b8d8ec5", + "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+o55pQ0i3TaO5YwCwJwgeGa55BELC0GmZ8RN+T4igdgzKZF5srvIV2fSqXadxCIhxpW2xDBsuqa8zoT/E1seULVwYOw5XMem9HiOhDp5BS0uHjngH1QvNSsVgalb9sGI39bBGW+KXnGFXVaxrt942wVRqPdTXQ6CjL5FM9prqkgPMWKoi1eyOYKeuk1EAf1mSpESQESjlXQvf7msXoB594d34bfDoWZYxhC0J+QKCAa97Lr8rIIg4zXnNnp9gkJtCCShGBCTHxl6E4oK9IaSrAe0xwsRBYles01KejGSN/JCfkWZbPqnlMvJzjZabPgzlo+FymthGf4XMjf22jJjyLFois77TFiJStF7CrZlWJv1CJ+A0d96boaGeQLM8oTfiWp+9+WwI3Bga4aSyNAV0vuatlG7FOe6RbvptmngXstNhvcPNM8xbFZGJLkyE1Vg9W8/CX0bCD53RB/Ncg71jjmu23Ssp" + }, + { + "length": 300, + "nonce": "8aafaa2134326197d827571d8f2052d6115065a0f309e1f80828ad3064622ad7", + "payload": "AoqvqiE0MmGX2CdXHY8gUtYRUGWg8wnh+AgorTBkYirX/BcmK4PWZ4E+dTRfXijdBUcN46eMhKxvdCCYZzNPpbaehKyrqk2Zz7RIHHi3xRcogcWCCm2UfSYzLm7tSt1e1TzwLQRYGpFb4IuUZFlxvp3W7ImKCzB3N2qnKvKq6T8EQ/HmpqUwx2JXXg5eawIbvZYd9VXZLaPnBZWnUKcJm2Ct7DCxujDS1AR2xPggvKhW7G4NYn1Pk44XBstIBvVda0OaQJjX+LARNRTJNR4RmqUu4zidwQ8K8P9krbzTGwhsRZUMH2+W4iNApjntAyp7r6Y/iR43dEcHBsCDgxM9i1i+G2YLBhTPCFzrzv+i1hxnSaHlYsf2Wv7U0HBEiTE/LcFLTZcRcSbSb7W84Alnf6DLye1zsk9yvusDg5raV3IaNsgncyr4+mybF7E5+WpaIMcWNU8ZqsF0ahGMO69oevhUXCSmapphSTMhzV3zPeJuAsejVLvqLfBV6ha9ElPNp/zK" + }, + { + "length": 1000, + "nonce": "f8d276c0db3eec61f9a59e58096f89efa0a9a1b59579ebbb4fe3ed5076300657", + "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": "5300dd682e29f84e412f8be1a74b544e18d2c55492d2301aecb6aa1193a9b03d" + }, + { + "length": 16385, + "nonce": "8f463a85648ea678abb43a6706d9b3821d45b3f68584c9179399de5277c555c5", + "payload_sha256": "f877326cbf8023930b9834704afb2e7211dc077c400ee4268ed0443fef1f02f9" + }, + { + "length": 65408, + "nonce": "c2c2c44e23f42580de972f3c5b607e01c8c3e5ccd50720280ab374150658dcf7", + "payload_sha256": "2f7da24f024676a247223b5626b859ca4a1b7a8e15f1535ac09a1433180d5309" + } + ], + "peer_pubkey": "2b82267b31a76630415185d5e870d5982d77a613f76814251b775b8e790fd3bf", + "peer_secret": "152de0e509e2a5324b88f1286ba08b3206243ca7ea574672f7c85e2143341df8", + "proofs": [ + { + "proof": "c867e649fe2c9eb18db1991f8d4d7e34c493dce8703ee82f71deeaa97659343c7eb6f1625bd6bba25a5d13bc4858e11c04d9cd9d2086beef87acbb6833988511", + "timestamp": 0 + }, + { + "proof": "2322583e17c68c90fb4d7b951f0182b669afc74afc3fe00893475a717f129dab3906a7c64508fe69a516bddd130b57bac1ed321a27494b6cf36c10ca084f1d09", + "timestamp": 1700000000 + }, + { + "proof": "66e2233dc41169f40633bb61cd8c1aa02a5713ec58fe923a14ec3ce6b1f4e957b54e73ade24434ad6e1f15a7c560ed9dea4350dbbd9a16abdc595198f463d1f4", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "ac2c1b950bc889eb16b5859b3e99a2861619c520b16c5cb9a857fdd5a39fafad" + }, + { + "announce": { + "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": "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609", + "sig": "4329993d6ebdb7293d6d2b14a8e1ece69737379b412311d1b303b5dce63871058b65a7a963bbf7db33e8419e484d8e3f5c2f8ea213e6f8463f42befff7835c59", + "tags": [ + [ + "g", + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" + ], + [ + "t", + "announce" + ], + [ + "p", + "c8105cdfb67c25d7c16cfc8766b6affc2d8a5a9acf149e3abbce80385d7f1d90" + ], + [ + "p", + "c579c4bda2e29644907a238471ac5ea5b96c976427a0d39e4c3af9a1c30377c0" + ] + ] + }, + "events": [ + { + "event": { + "content": "AsJWHuaifEFl6VNr8CgxsXcv1eyIEGL90ivUGIDQT3Ygj5is0GfFVtYuYmmpArYwUXeNH3KpCHywpMLthYfEXAWZ06QQAfsBZvmHVOw8KHTh3SdbI6xp022gGTaTZtOndUDrxnB4+fxqRanO+84hnXXUzwxfHMVzqhl8tVcp53QkFjCJrQJus8AFDwHzotgC9jDP2mb6IKxqeppe2SRqTo60HOtZvRYioZXL7mo1yy/PTwE6paBLYWTZWCRRA1vvN8Ok", + "created_at": 1791467349, + "id": "38139792b3a43e565d617c109ff1101161d71ad3b1ea6575c3be423e471821b8", + "kind": 24242, + "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "sig": "fb4c6eed35cda5ec2075c9b0414950e0bfc195b2e423e0cfd9d6e5675277cf27e63011dde1e7f6ea909564364608e9078f660528de31f57aaaccf503e408edbf", + "tags": [ + [ + "p", + "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467349}" + }, + { + "event": { + "content": "Au4za+9ER+5iLctE/AoVsyelsMdhIozpJnQMc5ebs3hDiLGbqG/zv5NGal7a2iOK6MHCj4bD2f33EvQTURSrfNSnC78WPJbRnn93k5v8G9uY73IvRJlUWO3TOzc2yU70iKpbuKhlAMFqnLKsTJDkKCWHYKcsQ2UzL0Dl9WxBY+bHFORs2SwCiOs6WStLcK5TPR7h3oSppq0GcSiNL/uL2PyhjwxD2zT/qU4PGU0h0ISlabRuMYScmSAZUTuG5qG1ZMBb", + "created_at": 1791467345, + "id": "cc1c709d33b6f4d5c30dcbdb1d0fa04b0b2fff108777957669b60c4c82bbd920", + "kind": 24242, + "pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "sig": "c888f7d568d9d2bb40b77cd7251652d26044d466dfdf2d90eb26353f722993da2ccd20a101a3e77aa1b1297b52dac37289b89050e33d65a74e85fc22c1b8c371", + "tags": [ + [ + "p", + "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"76883da1f2f7fc7ce3a7dc073114a0036d7c3f757711ae560f2c859dafc6e02b\",\"timestamp\":1791467349}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "b8f2e6775f251ea98d6a8ef5a5f140643e479defc638cf0b440c0ad3a9106295", + "payload": "Arjy5ndfJR6pjWqO9aXxQGQ+R53vxjjPC0QMCtOpEGKV8xVK7082vIZ8jV6lLtfXWi2UdQkpabPmjcs5W4j5JRP2hE8UTJYv7+1E6IkGHSQh0Jmops0ujEFSKebk0CK4Il3X" + }, + { + "length": 16, + "nonce": "c59282b26cc46a3f64c4f96f988b7becf299e64d74ea5d174327ce6e043ffdbd", + "payload": "AsWSgrJsxGo/ZMT5b5iLe+zymeZNdOpdF0Mnzm4EP/295Ln8/B8OrC6ZeAaDcs9iZpmORItAsOAV6Eg7VFiaBBw0HJvpakEGHylX/KQTaMLUKLAoCWWnP9NcIGGIwaAeLEYH" + }, + { + "length": 31, + "nonce": "829f8e09d4ff7eda8329d644f651c604e52adf12f4d58e26ae85c89134a93dee", + "payload": "AoKfjgnU/37agynWRPZRxgTlKt8S9NWOJq6FyJE0qT3uJx32nc1YClTcCwBQLknb6uZu9EKixIwFISyTrCPmVqoZGXwdUgvtqs2Y3R08laGLB4epJ9V9wzU2BcdjTNFEbK4N" + }, + { + "length": 32, + "nonce": "603e01ff6080e2d85edd38c40a87e939f406e01b805c0a8bda1db501ca23c63b", + "payload": "AmA+Af9ggOLYXt04xAqH6Tn0BuAbgFwKi9odtQHKI8Y7pSixoFXlvhyf7qM4ovbN8Kl1vRArNp60TZGFRyVJ9bWdpEwhQ6qyP09T5xYXKU8wdRqgGQ10zrnYlOkrhjZfMhqp" + }, + { + "length": 33, + "nonce": "d7c37b8e99c723616a572094952bb3e82562aa473e2dafdc6cff37cffa21195b", + "payload": "AtfDe46ZxyNhalcglJUrs+glYqpHPi2v3Gz/N8/6IRlbyxfn6xV4VeXQspoWtv7VeTS5LST9A6sSS4ZY60iBPksTZLCwimn7oJ6YwjAaS4XhTksgM9Fhk8W9I1wT5iXX8GzDoQytoNwWn2oTmPG8xM5CiwhToQbkID11BJDN+QtKHes=" + }, + { + "length": 64, + "nonce": "3508b7761c647e03af690a3d0264796891b366797408359d6e7dced38041e1f9", + "payload": "AjUIt3YcZH4Dr2kKPQJkeWiRs2Z5dAg1nW59ztOAQeH5Etb2Urj27XQOCb2iykPijGhaNIEAU4STuVvTglW4aNzVLxIhFeUdb6rDia8L7eleUg0TF3Koc4HGxUviD7eDI7++occydY4M5jyCUNnJnipI5cVcamVw6Ynab/dqkvi7cHE=" + }, + { + "length": 65, + "nonce": "9cbb46d702345d74fc1e62fe7c8e98ea8d0663eac786aef2dad29ce442cb42f8", + "payload": "Apy7RtcCNF10/B5i/nyOmOqNBmPqx4au8trSnORCy0L4bKv0Q1mAB/k1o/YoKNOaI/xtKoMEwawMYe8JpxCIK9hX5780CEx1su+79PnkvjjE64r2tg1Wpd5BmRXNUrBZrrLuCSd3/JF8j2dsGHAODw+7Kdt9PEws7Y0KPyypNESjeU1pehtb9RtoFXjQhKucX3Nwo4dn+bjPksBl976SZkdYpg==" + }, + { + "length": 255, + "nonce": "e0ccd25f7e14cb8d44bc2711fecdb5a764f9ecac47f4b7b622bd1bf4ccf9bff3", + "payload": "AuDM0l9+FMuNRLwnEf7Ntadk+eysR/S3tiK9G/TM+b/zSMVWyPbkrJM5LT0RoG3EOyw27VCBymYeou6nd2SsY/qbrYBD/gyC/sIMOWnK5yQs9gAdWF4Ps46Wnos3iAEiBxF1nIp7Yb7ih6J25FIzJA3Lj8fcZdI3NFEQPfCFQLtKL5uXpv9v9X7KIJynlz8PwUwg6oTkVXSpV2u5u9kjHwsspv6BEKQni8VjNjAL/M1nMU2ELGqfKhkCAD7A9SM997Q6F3fsV+J6Y0er5Htf/y77AnnGm39QjypgTvmWzzPui6shVvuNE1B/UaWt3+/NXnLMOY2hnO3X2dNdPBoCnn2alf20N08XA7njo9sBaJu5F0vV6VKxcQan8Mhcn26ema1pUqvEC2UC6hocuZr2LOo/7Vy03PYrsVEdMkKcwFUImnE=" + }, + { + "length": 256, + "nonce": "e9cada0b5fcba2a39654121ceccf8779326057e56aad0057a908fcad2b2cb86a", + "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": "AiNqssLKAq9IPRRCHRp1RNPRKzRaiVN5veXg03YyMYmQOtIrHMsOt7Fo5ftglNfE7a0dtOXP5p6O2eO/+5gZH4v80QBN4Z6lAMWZw8+Gpl3ZWgJ3i/1qHNrOu9AR/ceZnJ8S5dTuLuZRnAzHKSBtRidUNQRI/HQTVOtJSiv5v6H35b55cVmnN6rikgBwQ1fJKm8e+BJzISiY2n2qRtvffOASHEDrReJa85gId423WRyMhVsGgkiCW1u/P11f4t4bxdRo5Ia49HieiHfJWfJQ/FYqqf9RtY7DyRFrhPuNCt6oUTKnUJb71CMF3vu32xkDiByQ6in/WyxKxmMyWW9tKfJKaASQY4Dlm5HJfiuWIXs2JBrABXvEYSuRWCEORzWV3t4dIrmbfZaiZes9JGM9HGRCd0BvGxpGAHKW3OD1ms6v5ZnnMVkZNc5OUuioQPlFzoAkj7NCe2NsGZ+u6DrkgYKzfIgHwTep+iEKgMw8eWMYJuNyWPyCCJ/Zgqw8/9GL++jb" + }, + { + "length": 300, + "nonce": "64d384796bae1277fae95d440124e3e024f42154562ebb646731d9b00d74b826", + "payload": "AmTThHlrrhJ3+uldRAEk4+Ak9CFUVi67ZGcx2bANdLgmeI4dAnYXaJD9aSCCRuAgQNyv61dupPRGs0n2Gq3jCrT2cQlwaEtIeDfShO/PWlfSx7G5b/Ihe8oYbDiKyxM4plHhOSJSCb9e5CwoDovAv/RnmVbFC4uHcU96CPFxCveRn/eU7AJ3t/2/qbzOAWutky1QOAN5IaEctTNRkVEwPccvG3LTFMCkBppqCud+wvaiWKl8emZuvYA8IGy3TKVRI7ZyfGmEu5/UoQHpBvvhXq16aWE3Mh4JbN4aX7NaHalpmpVsiNHx36LhXblhUmI+/imkpMZ8+pa6m32DzDRefJwLRNyUOzAl5ZcyDDDe4d1ok2xaYAAPpaX3wQ9iq3j3MqtFQ58wk102nsL9TDX0sktk5orjJNqx/ywjCjzw7efK8Unc9uODM+T2wMDlIztgrJ8povaP74x2qmO9Qyj0LBKFMRLS9Ulqn56YsrYnLa2GQbNqy2Z7JmfmJClOpM51BgZZ" + }, + { + "length": 1000, + "nonce": "6d4e314c39aeb7e42c44525a4417dc4cd08114294fe22a36160c50df3d5a4bed", + "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": "912600738ccd168bfccd5e5241c492f07ced48a1fab1718c09aa2648af5c5936" + }, + { + "length": 16385, + "nonce": "ac23b1e608d8809557360341fad3fd434eb4fb7e3ad8b4adc57d32f04a4152dc", + "payload_sha256": "01ac3d8dbf0510498506d14ce199b7aa97bf17307aba331eab9d831109d409c1" + }, + { + "length": 65408, + "nonce": "69f405d2cf1a3ad0c5dd6c06fa841c0ab192cad58180a9bd961cd687e9db3aa8", + "payload_sha256": "b4adb6b5c467a289e782953820c64b08ad9e5237e6e8337b66d9f671e46b38b9" + } + ], + "peer_pubkey": "1c88063fdec8fe2f966c66caa4cb51119b94268144c4383f9090e7cd6810c0b0", + "peer_secret": "d08057dd8ce33af2699b9a44549e2b6ef1ab8bd3c62c4f42bf129065b596d920", + "proofs": [ + { + "proof": "dec5815aa22f5cb32b99f5aaf716b6581dfce93127bf42c10a1b086fcfd5627a762deed000e87e5ab250b883c7bd77539edb5599735e5ee43853c8e17d4ab3b4", + "timestamp": 0 + }, + { + "proof": "a2f932d1eb41aecd0148aacc0efa7a0c9544d1b711e08727f9b86933f696ad9dff5e7f0089a233f40dd817cd763e3f924e952a6857dbfdf3084ebbf92aa44bff", + "timestamp": 1700000000 + }, + { + "proof": "8562533f33b3ed70046dc7430442bdbe18339557142652ef7264531be5c829a0f92d73bd307a64b876cfe312365cd6832329c8fbabb285b8e7bc6151f7bdd1fa", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "4b98c3e7fa000af75e6993d543e73bfe2e46d5b5bf1a5025fc2ed336eb7a8609" + }, + { + "announce": { + "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": "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb", + "sig": "36d68b59394400bc0ddf9ec571b8395b8d77f41e954bdf2f8e74a142b2266aa71ea5d100113f36bbd0b2919f7a746a26b2deaa675afeb3e5dc309c8670381d50", + "tags": [ + [ + "g", + "8256a0249f28ce9b890eae92e852c015c20fd43f0cbdb533980f56268adf392a" + ], + [ + "t", + "announce" + ], + [ + "p", + "c8105cdfb67c25d7c16cfc8766b6affc2d8a5a9acf149e3abbce80385d7f1d90" + ], + [ + "p", + "9abc59a7bd6951a409d383d0d59dfcd8185b45b2e07b06dfab536de847397f82" + ] + ] + }, + "events": [ + { + "event": { + "content": "AqVtsh/7Hrq8ZWsPTvHvOcNaWcFQI6qZ0IWe4xOQDUDZ/MJwiXE9660lhdwC72F8rsiGf5e7JrEdLkcUcVHg4wd0sRbLVkj6IiRmvHy5zjex/Ga0V3qk8DWrlWXYqDIq4VensOXVMCdIrZZ5UJoOGQN1Ez/WpB319Hrwe1qfoUwae7W/122ClmHYw+eHmP9pgnLp+M7HFsSh1lRW48KV7fzc5z25MBPPMCX+OGfLwYXyqWzYVRKfARoFD+jwY+ngoQMj", + "created_at": 1791467347, + "id": "ad87e01b8ba7465fb40b31ad9322393ad62b373be849a3170fa6970b432c7bb1", + "kind": 24242, + "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "sig": "352ac4b89942eb832897afed46a8b2063c563875b476a156a05851b17c970cfe87669636904d6ba0b399194fbade55607368ab584374e80f9fec614880c2202c", + "tags": [ + [ + "p", + "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467349}" + }, + { + "event": { + "content": "AnfVTk3iyOi/mWb6xgUM9IPwduRlK4e0w4KApgyvNleWwz+wsOpVLhbROkX/zKPd6x0pI8OVKlA7tGneYCWV4OJb+Kf0/HHcE0SPdtnEh1itQPB5TLv3pvf5RW83V6OOkPXfM6tylNxsLwde/hqrgp65UwnIAt/env311/sTHq0xDbsni3lMyrliZDr1FXmEHs1HmZnqCjw/k9Ouqt+S8uCKnlTRyeVQWq88TTEtcHsJlNHoCTLxu/QQHjU5eHbw2myD", + "created_at": 1791467345, + "id": "7f050993f3a644e54d7773a015f7926481cf6da28ae328692189b179ebdcd00b", + "kind": 24242, + "pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "sig": "13be406aa07c0d51a5e9785eadb2764c3a2d4f1f80ab089b56f798b22950bcaf165671856fb6fb359c77acf63bcd0e8ce8ea8f9bcdecf9ff6162aefe96503b08", + "tags": [ + [ + "p", + "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"469466d6b702f15fa587a680ec6058051f89a2dcdaecb3cf9dff1a63b72d37b2\",\"timestamp\":1791467349}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "9e2a77c6d673d6d7bf4867ae2e21a690e909a969862da7cf69f7c1ebd21557f5", + "payload": "Ap4qd8bWc9bXv0hnri4hppDpCalphi2nz2n3wevSFVf1yQtgBfRQmVNhI6AWW1dVyEVxiYPOdllaAHVWWVOiLpOtEW5Uo1uG88Xljf79cYoZN7NV532qD4uVs4Hb13WBf1Dc" + }, + { + "length": 16, + "nonce": "535994757130a18b2a32a9cf97f5e0547eaa34085f3ad74ada82cd2f636d932d", + "payload": "AlNZlHVxMKGLKjKpz5f14FR+qjQIXzrXStqCzS9jbZMteYLdf7l9Tdg6K2boL6o9kzotx+qnW5e9ZRDU8IEDCh9fnFLkgaK+O4XDslEwvMYH6J5F6w15fgQHo6JQ2rv6s8Lt" + }, + { + "length": 31, + "nonce": "05bb75660c644972b205a0483897cb145ffdaf56ca87d91a24895897172fb6f9", + "payload": "AgW7dWYMZElysgWgSDiXyxRf/a9WyofZGiSJWJcXL7b5gh+p27ZyNB8SMU6BDgkrDd+wnK3uc//Ucg9agviJ1uRZ7Og7MxqlOuFrDgG/ZVxQbtN4PQv0KAqoaOJDGUZgHUXM" + }, + { + "length": 32, + "nonce": "3fd542f4df8fde9aceebe044cf9d3b1bd856c4f5e41e3208de1e538cdb7db141", + "payload": "Aj/VQvTfj96azuvgRM+dOxvYVsT15B4yCN4eU4zbfbFBpI8w7kowsYdk4bjkXAOOhfsNpJLy/RT+5P0EK9WPftYIp0AHCHavSIyvu1ccl7R3G4lWtoOMeN+wOxHo7EA5tBo9" + }, + { + "length": 33, + "nonce": "43522a905753c2e7b53d5cfa5d24b2b26ad302b93c728673c7cadca254cfc923", + "payload": "AkNSKpBXU8LntT1c+l0ksrJq0wK5PHKGc8fK3KJUz8kjJYdGLCIcIQIcN0w4tDAESc2W2FrOTijn2xUItyKQcayxjLULRlr8GkiL7L6xBeIySLdp34tfLF971SlGLvA1tw439gh4b/sD27Fhrq3roVjHHjg8A3qFWmTwmg44IV0LWrE=" + }, + { + "length": 64, + "nonce": "87ee9efce73ded10d6eba1295eb83799494fcace22215dd7b3ca39e42663b501", + "payload": "AofunvznPe0Q1uuhKV64N5lJT8rOIiFd17PKOeQmY7UBEzki5Y1xyTKO8r1xjGaMhhdHWeKnnb8AfpZdDcqrpv52DC+ZgG6UCa0zTySW6IwLvtCuj+/4sMay6XKi/0SvGuKET83drHerc2HDiY5elUXIQUAvxQLaTFwichANS/tXOcg=" + }, + { + "length": 65, + "nonce": "e682c259fb54aefcf20272bef0677b1a0393c2b5ace572e2f6e2d27c5b3100a3", + "payload": "AuaCwln7VK788gJyvvBnexoDk8K1rOVy4vbi0nxbMQCjmnwjZaFeN/iPuATmc3iqf9L2QzPXkre6eB0zuuklyqha1ncAedh8N7JP9q7Z7fij7f5d0T0uBzOJs9tcX70F30BGgPIOi6dBiDJ32/l/yiR1cz3unJzm3hgqt5srQUGgkf8dCMiV0oIGONd5udniVB/JWEmdCiFrd42QQ9QCkCWxmQ==" + }, + { + "length": 255, + "nonce": "e88ccdff56a18bb1f04c786a1764e06a4626cf4e5f73aa7b3f8df409df1823ac", + "payload": "AuiMzf9WoYux8Ex4ahdk4GpGJs9OX3Oqez+N9AnfGCOszQOc7laOMB5V0uYpmwb9Qxaw7+w8VTyl3r3ZkupA7iEYgRjHz6vMpNfamMxo2WC1CtJkBrXZKJ6KCJ1vN7E3Jl4ci1m/w62CgSO/A/XBw/FlfsjCB1s3HxTX3dOy2mp7ICp9+Kg9W+VbK95alpVuypZoe8+xtreduK937Y+mmr6ocW06yBoYL6EP4T4ehk0qIWOuO/wu9yA0jPUERMnTuJPPWCPIkgNYme6cPx1Q9sUpPUBrzILFHhunuuMbnHld7l1m+mNa1fs1ifnNfsxktXaMsnl0cxJYcbFKDwADZFQnn67okcy8TQdWLoWgnaVzrbtaMeMPExhUgYpRwiiijojV+InyOTywY9TTlKUuQKjOE/4vOqNLWpGJQhW5u2Agnd8=" + }, + { + "length": 256, + "nonce": "e80e6934561a5bca256951d0be90f6f137b4c102b042f59b65c476ff4df1d503", + "payload": "AugOaTRWGlvKJWlR0L6Q9vE3tMECsEL1m2XEdv9N8dUDMJEsxje/Q/eG3HelDrsK0O7Qvj2s1rG2jwFdpR1ydX/rMz1nUc8q4zc56KErmuIB713sydVWHQvWmJR4CuEHsD+cflH8A7V9i4td+rVPgfOAHwSGFaGQX2/2HzuOyYzy8TlpOpgrfxe0MCu3OTjsJXqdL+p/QificXI62CGmgCPNKY9hwqmMla+ArGQmFtCmvRgEXGfVZwBPQ3zcsyKWKFS/iA3wE0PzfecCai3ej7eUord5rrRbTD+xaXn7pP3anayuiVYy5wRYna7lVIYoLpOKj0UJ/o+QJGXyeB3Dr7ZzC+qYV2egrBDVOmEFE7mZcHfRr60FmyFV7m9MBxUg1Tky1xx/DDrHXhTMHZgqWBgV8WA1hmgQ4Ue942bgGf+xcvA=" + }, + { + "length": 257, + "nonce": "e3205bdb7ac94d53dd1f4d54825bb913de6f8ae15d5aa85affcadb6c9b8ca227", + "payload": "AuMgW9t6yU1T3R9NVIJbuRPeb4rhXVqoWv/K22ybjKIn4O75Z+EEbFvgqAwCOkuNY0XfW22WY1RyMo9yjGy/7wKkJrgNvkObo01yZ8lpudkEScYiBwMLi3VCq0dkp+nCXBBgJOjbf2NaErsuAefIowi6dZ9tTmZAHrt33pakizbewJiQ6byeP5wPzkLE1RlqvkO2g1rTIq1wP7rJdAJvvyMjjcv0YCm24ZWt6dRxgmuXNs3O6pYpvgnPWuYx/q5VUuzupSFp6jFObIwdHwuAmAUjJDnf5uxA9+NGSwjTNJg6OYU0165tbWPycn0rMeS/em4mbzb8mzLY/tK9GRnd1k5YPkKGCOYF9PYz6u5npoGDVszkTCBF4Q1NH7qxDJwApF7bfv4G2R4l59cWrh0vucePcmI/NS4uyjKD0bsjXqbx11L3jLV/7nTdi8ly7Bc629AZRSOeH+8JvbjKPhsxc9XT4V4vF8eFqUmsdjWVVk4LxHjrwzeEx/vHYqnsqd0yGF1F" + }, + { + "length": 300, + "nonce": "e479da7089c604647c0b3e9ec3d6e5d04fb3750c380bdbd53846fd0940f42bdb", + "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": "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": "b69ad12ece73d3c1e92cd9d10033c5bc62cea87db6aecebe4a066dcf13dbdd23" + }, + { + "length": 16385, + "nonce": "b273d218fae37ce1595891ad54d84ce94d2b17142cfc030687a01adac3badec5", + "payload_sha256": "56960d164f92c9851aaa3a72de10aeb9c5a0dda400bad10ceb5fa16c645ecf7a" + }, + { + "length": 65408, + "nonce": "8b0e611b7bccf9a3bdf9d25bfe5423a8cc97fc6518ced6db38a766e4b8070bc4", + "payload_sha256": "8aa9e1d5a32510a67ccd53377d20301d685a9edf6d9512bdd293035ad8e6ac38" + } + ], + "peer_pubkey": "36365439aac35af74343975748f8cec363606e39a60b255e14f681c31e1834fd", + "peer_secret": "fba71ed001d0e1906f118958c3dfce27ab9d4967b127aeff8fb8643b81795d57", + "proofs": [ + { + "proof": "53ce13dca0534b7980ff0291bad44ed03d60922299e5f761610e3697ec7bf699eadeab93f0ceb3847873c53931db2ee7f769defa8765ef294d62012879cccf7b", + "timestamp": 0 + }, + { + "proof": "5573b0ab66686edc2c92bc657327e7ee1d8e357f4004fc4cd0ee3424b532d1934763a031397bca7dcd8b76129896e8ba30451ccfef18ca8cdd1b3e6a34d9e08d", + "timestamp": 1700000000 + }, + { + "proof": "a57eab79a91b8b5773f89fdb8983cbadffaf9ce1b72fc73a29effc722afe8e0b86d6d771d3691702c077df2ae19122cf1a46d52f4edd81a8421428c0156868d6", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "5d97a24ebc8a9d31587e400cb61499f7aec0b0739d425d3998604aa9d43dcacb" + } + ], + "min_signers": 2 + }, + { + "group_key": "03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc", + "key_packages": [ + "00230f8ab3000000000000000000000000000000000000000000000000000000000000000136d773a86602d4222fa947d9946b0c37f0496ee8f42c7d8b5292dab76e799e40033e39590946701bd1e5d697c3d620820479a0097a96f5d5e6cee2454ef320d73b03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000020f5fd06e63f62dc9be6459553e03ce90e8147599a12164b367200c401e9ad9e802c9952dda17cf47641239975d4aa6a69f83ae8ba0aae687a146ee0d5886c4dcdb03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000003e7e82d3461e987714d1f6ad0e79c90e89a8e5930fd5eec173b7f9c559ef256d10274c264121e801f3b609fb8d44dd19b4b63408609154c7750d4e6c536d59b4a9a03bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc02" + ], + "members": [ + { + "announce": { + "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": "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67", + "sig": "f3403ced87bc5fc55f641be1b3f4d6b5e94c57c03011b55af21803e776ee763f2d575078d40c8fc1ac46a409b06bd70c04dc6496492e9e5e988b17441a1f88d4", + "tags": [ + [ + "g", + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" + ], + [ + "t", + "announce" + ], + [ + "p", + "178fb6dd67b2eb40c29a0ac53416c5fc9331aaaa35350ce9babe2820311efbe2" + ], + [ + "p", + "7e03f48a9e0591ca37ff0399df74d8a5b45764d55f0b31b33e09c84aaefaecd3" + ] + ] + }, + "events": [ + { + "event": { + "content": "AvpjevDSjcR+sqvz/tli35lJcVFVGR+OAnSJZxIisLmLIrhlOP0waVOSM6ZQ9SD5lkFT8M9E3xpbOWxB5o4YeAMnYB2UE0tcr/wUX0RvrI/D8PaUkWcJVJDNYAAkqApnsUq5dVF2cHY5DJHr1JWHwAlXw9Za4DPW6r6WCUE24AoquTB3F4EyTf5miAVxbfUzAMkeajNfNQDhL0YNIOUM0/qyKJyxDy2kZh2j5q7P2juzNYOn0WfaFZI2jgZGmi7PfPvY", + "created_at": 1791467348, + "id": "1e17e0564d435e5176e3033c0cce28827640cc0f9cae14d5aab01585e56b26bc", + "kind": 24242, + "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "sig": "8eaa0cb9364ad57c1e91b32295f8b957ee704dff87f03f0f489febbb41fd05ffbe7bb15cb0f11542440a2632e398cc45023e0ca3bb11154cd446671a304d0846", + "tags": [ + [ + "p", + "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" + }, + { + "event": { + "content": "AiFjBKtOcEQCI0H3xv4AXxfO0eZdP0PpL0hhx9hfR31+h23V0905hfnN642iQ0x6M/PXZDPtqueqsbbdYL8fpnxEYdFyod7Fq5lzLdiWbhmTD4Y4SvGBtWwA0J3XMg71SGE6OpaXNaWc39UHf0Syfo+RgoqQYJVECbpu4qu1YRKCgX4rfUPtgBGT0fecVtIT3KXR3tf6/+JMFqdTQ38jRKEW0qP/LO3A6ZhecsMqEst4ePMqKuzr4HH1Kb+XwUQsGMxc", + "created_at": 1791467349, + "id": "14be62fe84510b3bb8121428c1438ae13ed3ddc050c7a87b9e423d0d29081ecf", + "kind": 24242, + "pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "sig": "dab2891deead48412b112d1c2ec52e0c947652e6043dcde1ea2a3e4eff14ccdf5d3d95d933b8a8336538375d8bc3afc6431aa3230e75b1bc6b9452375880cf5c", + "tags": [ + [ + "p", + "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"5551d4faee7e9e06126944d05bd1e4c8a1b6385962b19614aa35f3be535e72cb\",\"timestamp\":1791467350}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "695138b4a46ab95d11e815986e2833fed7f27679478823986822ab7c495a9e14", + "payload": "AmlROLSkarldEegVmG4oM/7X8nZ5R4gjmGgiq3xJWp4U4N4ULZVQpsy5lxzbKvwzqzvnD0mndC8ur7rAUt4+Ejicp8ydDRLCZDaN13vTL1wdGv0PfkIWIK1Q7NqOga1mE6r/" + }, + { + "length": 16, + "nonce": "2cacaaf9c2617c55b497391f37f7ee8f62f271732cf83e68a4e99ac4a09969ac", + "payload": "AiysqvnCYXxVtJc5Hzf37o9i8nFzLPg+aKTpmsSgmWmsEw1V8NaqLiiBR+W7tnYO7hD7s48XS6e2ed64kcnu347LjJCnHaYEFDnNvwmj3UGOd1E47CkeFiXYZRdmgnYWpV4s" + }, + { + "length": 31, + "nonce": "c901644166d87da5f50f5a7aa011c023ede31bb743e6dfef44c9656c58dbe664", + "payload": "AskBZEFm2H2l9Q9aeqARwCPt4xu3Q+bf70TJZWxY2+Zk5D9NcMFyCSvvMOKbOn123M1w1+gznK5gLYC1UOwk53NXpiFwzBzfyv/ZkewYCAL7JMhAjjTHyOCWwDjaR2I3Qv2Y" + }, + { + "length": 32, + "nonce": "017832977b614514ecedb8308146d386ced3a07d2859d9940753b591bbbd210a", + "payload": "AgF4Mpd7YUUU7O24MIFG04bO06B9KFnZlAdTtZG7vSEKCNPX22IL3xiqpWbMXUyGNtWDiErU6OKmaC6gaeakudxm/Bu0kjAhwXK3hBSbR7eY6X1QN81Dnt13xKyLspfuTKwi" + }, + { + "length": 33, + "nonce": "3623a8c60de9ef7de5ba0e517b662c38283614e71a72de9feab54af9b93266e5", + "payload": "AjYjqMYN6e995boOUXtmLDgoNhTnGnLen+q1Svm5Mmbl7LTqdX9sPH3l2YE/6HJkPqucAxnJ0Wf03w6oQcgh45cwX/dkocAfNoXs4/HYmMLkv7A5/8lhdRXhisoQM9nFvPh2NoOD5e86X+GVvzXV8b9J5LNYEbNYwVX9M72z44s6ds8=" + }, + { + "length": 64, + "nonce": "aac82121ffabc5434ee427a37eb172ce4b97772a3e8d95b9414cad50611571d0", + "payload": "AqrIISH/q8VDTuQno36xcs5Ll3cqPo2VuUFMrVBhFXHQDaNY/tLU4KbH+gqCAgVGUcXrpSlVd+bCNfQmeMfE+E1vmdRGiNp6I3JEk2nhaWm4nDTHfwxioPouhREd8OzbSScWNV7BERlCWrQhWtWtefDptwxnBD2zSc4ThaUO3iLZgsE=" + }, + { + "length": 65, + "nonce": "0abae9241cbcb80f350ae383202b8c16e8428065b27d0c6e4db2b5290cb3e6b3", + "payload": "Agq66SQcvLgPNQrjgyArjBboQoBlsn0Mbk2ytSkMs+azqZOgNHi9ldQyyy66B8JHvB+cQy14m5eJidPLsGtv7X5ph2v4RpEr4UmR9JnPTnlnHDpsbDFk36zE+XPhP0mKwVFAugn8VSnFRtFCdT37fNeoVTZNsEbJEDgiaN7xyLKW/MgasbTnBzj72lEunuGcUjS73yI+5tQZvyjM0q7woN4TGg==" + }, + { + "length": 255, + "nonce": "b1e50d189a764c5c74ba493fab3c745ac8ac0d340a7e6aa024bb039a77cd005a", + "payload": "ArHlDRiadkxcdLpJP6s8dFrIrA00Cn5qoCS7A5p3zQBaE5A08i/wiEMP3U5hJvaBJ3+dWoFllGMppkJxUMbPDT4aZDDWATNQf9z9Ldh/M39vNm17iOfJtx8qDAodpJAJSjgqWemHHG54qRj+9/AsinhHP43Gj3zKD0IeddZRZdh4YC6qxbmO0NzZ/9ucPBhKbLlQJ1nU/KXn2OhDhFNNE0MEcu1mc1OqfAFugGVBC15a5+oMDFplvgfNGjikRwETUg77tqUH16gKrWrXYAgWvfLIQSmCZ8wD5m5Di9xpTgpIpcSG3JgWlq2e7EILgz4lAw4FAHe6KQmHfBS+vr6PYsfivyEEbSPtR15Ttoqf6tm1oZgr3RaltXtOsQj6ecdd3cV2tbqFsCZTdDV2AJJDNCba7nzYgH9XqPcoWfZCHw+ZhWA=" + }, + { + "length": 256, + "nonce": "b39a22e1885eedd78baf6e976e33bcccdcfda99b100b93cb3aa292a239e30fc3", + "payload": "ArOaIuGIXu3Xi69ul24zvMzc/ambEAuTyzqikqI54w/DI580Xptw25WweeW9ppTBmlbW6ySRcRG+ZAjD6aHQOjEOIXZJ8qWK+wwSUuty+Uuo87CleCAwQLJzr8F+wfc3hujWRwRnbcyofJZHhfdzLtWng7ZEzOVqPF47WYSqOceCkvkx5Q47NX0MY6K7CPQqAmqxQ6mmvy+IiYBDqpQvUduWY1adiXaSIE8znw2/N47R386Jy6eCRpe+I2VhE8hjBtY0hilT4yLj5E3/CInfeG9B8qgZKcl4B2YaNvlX8A2tHdJ3b5Y5TMMWREY/MjL/CDVo3uIzfiEIZcqhJPD+e2mwLed0mODzJtepEuort6JRCt+JkG7ykhTHsSy29mGMu9ybPnGlfvO5e5csQ2Gr2GMtWW9qefV+G3/iHi6LazRAQJE=" + }, + { + "length": 257, + "nonce": "b3c08b3535f61f830360708f69968daf7af5c411b778c04939a28e56fbb1f0f4", + "payload": "ArPAizU19h+DA2Bwj2mWja969cQRt3jASTmijlb7sfD0IkveV+t03wxnr2jfeAm9+had/yHmmNvrgKpUZ13Na9a5+1F20JVqiWvehv0IY10IGm8xyxI6KBVkJ80m8VG1bG0b79dSFZo8cGuxznfP4RukVe13WE2X+PHWaxEHpdYdrSjtRo1i/mm2OC0SljpAq2qzg/8umfMHK8dnnHgWjCVDVvXDIPdXlpOXVdS8FJ4sAHcHZW5J/9KDx5tc71EwM5fUb1PQPqrvcQPuX8/Xt+6Uu60eSMOHZHLw9lSW11Qrnw8cT2bomeLMLsYl0d6HBAjMH5qsQkiA/b7gBshxz3T2fBNOBnEybVSycrGXxxHdf9fLVKRTtXyTK6fSLrjWbVojLhYBCJRPux4susdABrf9rRVYNYXEz8spvlndWzQQkQaYt9mLzoY2WGnH3oWWPbXxiQ159rv6fD2UFQ4TlerKjwBVpLlmViO/tifRlFnSVKlBPcuAuR+0Uld0j/cVAEew" + }, + { + "length": 300, + "nonce": "7da2b5d0ea268ee0457993b08f40c909a8bca6dbe15601d2c7aba29fdb4a45ac", + "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/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": "fe9ef9a0551c7d52e403004f20011b78c0c7349e21d57c9cc4e7bc9afbb881e6" + }, + { + "length": 16385, + "nonce": "a0643ce5ded80d33414e78a3aae6e3d48685841af294fb8a8bf2f69fe23e2156", + "payload_sha256": "e31bfff1381add7ad7abe54116f9d5ed495af617ae075f7e91b4995b283c5367" + }, + { + "length": 65408, + "nonce": "4bd481c509b7cb6dca03927ad5937f890dea5d0be4fff0db37617e9801ee58bc", + "payload_sha256": "19c4097c0ecd4e8ae9dc4f22c0c687bdc4e76a7f5bf3e02eab5369820355728f" + } + ], + "peer_pubkey": "a04193b90ae3bb9fb963a85091865abaa055296ac9ae8364e077a9de23142da7", + "peer_secret": "ca569568f08eb04e77a3977e2383669b0d256fa180647f42b0cf94478678df77", + "proofs": [ + { + "proof": "c6da212dba4edb75d288d5983290b74e3e909ee514afeb63bf66e467ba060bdf95d032d6c5605ffa34f184683c4a8519a4bc770d75b5b6937ff1eaf372dff471", + "timestamp": 0 + }, + { + "proof": "4c78de347c8d39c3675f461dbeb95459bf3bedcde79e3026c711879239c9d369c21dd36e99686d9e87888fef64aa3b46bd9f9b93cb9dc3f3ec93c43856b7219a", + "timestamp": 1700000000 + }, + { + "proof": "23cc66037c5233f109ba6f9ef711961b16d896fe01c143c587cb65a490e5227d6eba89b2d6d5e2db82a9e6edbfa97e7804912d69d1699553ac1714a860156450", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "aab854dd4314ccd80c51bd2258ef799315bf111b18a9ad83b913a3d3050b2f67" + }, + { + "announce": { + "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": "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f", + "sig": "86873441708f63e4828482384a44b77fcb493c0242e02b1abc2dca9565bab6de62b194e715fd1d3f4f5d153bff25227d980d0be31826da5ef25ea438510f2ea7", + "tags": [ + [ + "g", + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" + ], + [ + "t", + "announce" + ], + [ + "p", + "0227fe07fce0572e529e753cf4e0eda5b56ee794919639b42b2e42d68e064626" + ], + [ + "p", + "7e03f48a9e0591ca37ff0399df74d8a5b45764d55f0b31b33e09c84aaefaecd3" + ] + ] + }, + "events": [ + { + "event": { + "content": "AsSFE6h9XNn6v8Ymi5dCpgPexhtIYJaDGIlM6+6aTieOY+HtGe1HnsmEvADr2blWJbs1gX9IjBCXsvwPwpBWpxn/w1uFY1HE6NNdV/SNrZfqC8kIYl11MZqllLrFqsoh8RZRS0YiJrecT4OPxspmo258u5gGXCnIHXIHCC5ZIkhSSZP7IqcG3Kr7cD0G0ILqGcY6mK0mpszvZqIRuJYOQvNW8fG87zDZTdlzRTBmq8trOGrt60ZeBUnyIodNrDHoUM0T", + "created_at": 1791467346, + "id": "5cc3e1920c54884b8c2eb2c1aad1354056799e76ffa15a9afb00ce24086a4606", + "kind": 24242, + "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "sig": "6049262e030fe25bcd50d0c6f14e229de7beb4380c75a4c8d591f745091af4854fd6725e7518ff82138154279f4aeeb99704d8d235a47221697432c2138aa58b", + "tags": [ + [ + "p", + "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" + }, + { + "event": { + "content": "Ar6oY1Eoybm6Cj6jGlbOkPA+AMT4LZynKjduny320rbFhKt2CZSIGOrn3S07u8LQ35jgjeHyidS2DQJN2o4d08V7iL1vfEdptJkBiVWchgUCh7QJPBKUjB2qzFpdTFo1VVsRamZFfsifx7ag9dMJLLWa8zEIwL1v3y8MgZQfoe7w6Y8233/EQobLWsYyL5G9o7JTqhQVyMXJtduU7XRyszR3LrL5905+wYB2JlU8viXktwQqh94mLUGzxmMZBD7PkDpp", + "created_at": 1791467347, + "id": "90b28aaa34031beed4a71d299b93f0662249b08b73948db58647070cf3030be6", + "kind": 24242, + "pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "sig": "84cbee28339ec5a43f97fce91278cc5861afd6dac0188e89785bdae365cdff4f7297cb92ef71d1490bf4cac224f59818ca84c433844272940e1992b5901b45fa", + "tags": [ + [ + "p", + "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"213f211c85381ec156c1c2b6d4bcec46d311bdadeac36adedd95b023ec91951e\",\"timestamp\":1791467350}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "023adec4b3185e853d29bd6d700791a32ffe1e34586a96e5c7b6552e9e2f507f", + "payload": "AgI63sSzGF6FPSm9bXAHkaMv/h40WGqW5ce2VS6eL1B/b20HODjLmlEnhdB1wtubceKRLunXgwQ5onP0WNLGJA/uGjMLEA83vHgOKqFI/xY1w72rbOyOohnz0w2vd05R0WuP" + }, + { + "length": 16, + "nonce": "d923bc84a276b3952a585baa2bf3cbc3a6ac5064b05a3f3b7f54ec7b89a6f2a8", + "payload": "AtkjvISidrOVKlhbqivzy8OmrFBksFo/O39U7HuJpvKoi5t3NcJotCZkiZqsv3E+vIY0+pUWEsxxYsde2uKLL7tiU+Hm8XlNESNnOm7fHqC01v6e64h8ER3P4KX+7aBa3Wrs" + }, + { + "length": 31, + "nonce": "456922bf1d29520ba0b9763da22be2e4af1c95d0f77c6589eb1ecbc61ce06392", + "payload": "AkVpIr8dKVILoLl2PaIr4uSvHJXQ93xliesey8Yc4GOSLaifWjadlUmzRPFVEtrNdmex6jfQYoY68XhbM50lHwR8hSHA+UFDB4F6CdSA8cofsIu7B/hYkFDhREfljTqEXM34" + }, + { + "length": 32, + "nonce": "a4646a505abb3f5b267decd7e8d18a7dbf05bbd06f9a02c5b43d65a53cb63fd7", + "payload": "AqRkalBauz9bJn3s1+jRin2/BbvQb5oCxbQ9ZaU8tj/XvOSfkVVoyql9mT9eB+n9J8gZOn2VwgtzyVRk74ikUeMkWoC8uup7t7wrZJrlJbwOLNuzsHpF9rWPgE29kQxQjiHx" + }, + { + "length": 33, + "nonce": "4d975bf472a17c4b1e1598e0ff76d76f54f2a7ee8a4b3063c856f42a4326a1a7", + "payload": "Ak2XW/RyoXxLHhWY4P92129U8qfuikswY8hW9CpDJqGneYV27emOTk6IdHGwi7hnzBb5OyshPCHd9N2WHUEsdP5LXG1FiXw4UTypyWgIpHnW+ue5XQq2HlCQ5tzr4jButRfi2aRNgsSIB0K2gAsnZ5dY269ZlzCyFA4+ScjDz3Z7248=" + }, + { + "length": 64, + "nonce": "1a0971dfcfec48a57b06b2326af0dad4d6f035cdaed762d83a8532fa70ba33e8", + "payload": "AhoJcd/P7EilewayMmrw2tTW8DXNrtdi2DqFMvpwujPoSyfzC/T9WHRM+ToBilg03PBv5+EDeH2dQzmGWOWD5HecF+vATRobLMdkKBsT+wCFGQeVYObeHgUyAilXqgozUbT6OE2gFcXUFwF9HuXwAAUyYL7+CxmlGZzkpAInJZ+lNtw=" + }, + { + "length": 65, + "nonce": "bbefce463d9280e0ce16b3521d4619103483f632798f41fd16ae0fcc3d218752", + "payload": "ArvvzkY9koDgzhazUh1GGRA0g/YyeY9B/RauD8w9IYdS8xiSP1ntrL+cxJCxGn9/GLX5KUAAVC+Lyumbw5LTVIYl+K91Tx1CfS6cYxEsmzhe+pQg9+zQ6wsvxXpf5x2fSv9owgz5zItPZ8tfChRWFV07AiAIGrZsTKScQ7HcIyIB1CcsKyT2yfnKLdffHKe68bRQ9RgHj8ex+U4y6gWKitzSjw==" + }, + { + "length": 255, + "nonce": "1097689c08b5fb673c55277aa3e9cfe47106eaf9b20e42d0ed28814a4b69952f", + "payload": "AhCXaJwItftnPFUneqPpz+RxBur5sg5C0O0ogUpLaZUveuDpfocCYxJu2e2Y8KjgO7W1r5bOvzJk4GpDtU9idnawP3AAZqo8YLm2jMjLxQx8fbFTlyJKznKsFRkQRH1WVGPglJDnUaroxs/TTnH4DRidQZEVOGLJ6xuTcd2mHETAtBEvZdhwbcuCjYVnqFqpg7QX7LpVdS95HUy7Dh+RTOk2IuGC4tfSfGOi18W/AIe6v/DyQpp2yNKwtcoCmzKaZXZzYTgGgNdc0Itxw4ARcvVpXJx5twrKh+6Z58y5oslpLbo088GUW8uYlP+twoG3HHWF5I6ftq4FIe22oVRVhlYtWDmqZPcEEv1hh8MNYdxNHby7xulYd3L26+hlV8vmKYVwV4tP2rJ2Z9haitECBLIQkv8n45j39D4heGpOrktwqlw=" + }, + { + "length": 256, + "nonce": "e155e03bc1ee3afd0b4979a151da38090e78c3d68b318f67d617a8032f454ec9", + "payload": "AuFV4DvB7jr9C0l5oVHaOAkOeMPWizGPZ9YXqAMvRU7J5bksUjC2XxTri1mu3L2pVRCaSbW2vmpp9NqH2YXfCj/xVJUYIAaAenfwr5ZNPdGVaapajEKGKdje5dBeH5R3LUgqQsqGNxWkEi9Bo3ZSY0pvli7yE44Fe33jOXgGATjqxFGsO/B8+0KH1GISA9NX2Q2RNMr7KrMHoE8jQ+BJNLrhaKlkxP475yfzpWex/V3XIJhhhRuYpz1a8N/utmeupCFxqWExkGWJQ48KAwcXRfR9fxVBCxGwOSdT7FJr3h899alh/NvWCHuwB2OlWvonwXo5E9QrPwli50HcvYRUPXniZXSlS3iEpzBGepeLf9b4ztDuSgGrwHWtaikGsB5j6RKZHXjgCmJGlpALRZF+Zsekb1CRmclj0/PSR6bcSfRl0BU=" + }, + { + "length": 257, + "nonce": "65e20c2b49f2b48815343735e35bf7c802b98bce8469cdc1f962ad3494a62dfa", + "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+1BYekfjpooWUTb+Jl8UH1+qrvaeasa4OnX9TCpOsQ5HkkmDeDqGdCYcEHziI+JOqHLeHj/Kq84+ZA6DzReT1LMyt1Q5tJsfYtuOIUOsayCHgfL/ZscaUH+VZzlKq3UXPb9vmgK5B1iBaTUd9JevUxGIXKgNo4xHaDMI/fzoZ0ahxpktMKvPFy640arHlKCQ/0JCjQaYxDPLJTidZ6LxwaeCxOhxnhRR5xbiKrTZ5UyMgRXKQeDPg2g8zDE7bfGDrtihvt6cAfG9cEZEUQiWWwBFeaa2eKwWNkc3NFFFjipHawjXoTFh3wykJA2duWPpHp9D+ztwl8OISutyahFPdKmlrL2tWJ6MKhq0YCLkqB3IO35n8i51tZ+pN3LhtqVSW/bRJQJTI8mijldSYIZxdHJOhJ3pvEcWGDuhLTaxtdB7TG1JCnB4LsqfozAMWOfCLpYItbNx7vmXi7mHpWHZ6+qXc8Zqy2H9Wst16" + }, + { + "length": 1000, + "nonce": "aeed88df44b7d7a6bb8f6ceb7265e04a9b8f82c5fa524e5ec2c293a515e66126", + "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": "5bbf5ab93d874f4124525076fc34104d29d17fab08e0027f5d00a52a0b0675d0" + }, + { + "length": 16385, + "nonce": "7db36db2f88426e9adc5802956bf00113b27e9c8324ced1257ac8ce1dabe323f", + "payload_sha256": "7b0fb7b0d35f3eaffda69f0f286f843db70232059c44c6e3d9e4b7c1f9879e67" + }, + { + "length": 65408, + "nonce": "73a093dcc5202414c2a42edf10400e6508869b5fc44a607984c9b27af6d469ba", + "payload_sha256": "3e4041edce1fd12eb63c5006526e3460f6c3c3c2127d9cfde812848d2dd13ac5" + } + ], + "peer_pubkey": "cffca5c0bc5a412c4a0d9378ead3c12697141cb9f318f351d8af8289b1d596b9", + "peer_secret": "f5802d7def95d950fdfda4bb3e4c119769b87389eeaeff80368f787124edd057", + "proofs": [ + { + "proof": "4d968acd993a4b99444707214898846264f43df581cd25bfa69e1a2bdab4275a72aa453c79e24f9409edcfeddb20d1c14e58b2e3ecba89131c9c8458b578543e", + "timestamp": 0 + }, + { + "proof": "54821ec5873d23ed72b09733ef2da0b29bf1c6b5761b7e8ed27d0a813a71218795f80e3b2c93db1916c0f52b34757d5b079238c475019a76a98f3f221fafb03a", + "timestamp": 1700000000 + }, + { + "proof": "f8eb6688f4012c55f36156a53112aebb194304ea854d0f234ea12ca8dfc04107b5701a224114f9738db203f85a6fd207ef64ef6e5363eaf02b5d993252ca12f4", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "eece779220df1bcb7179c9f4f243bc47615dcef827316a1d8c0b694c2c01927f" + }, + { + "announce": { + "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": "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d", + "sig": "55fd84e1bc8f853de6d396c49399ef8b8bbe8358d5688320f5a8daa8a4bf7bbbdd96eec449fdcbc563e54478172d19af4c5279b5e0ab5cd9590d94551efbd058", + "tags": [ + [ + "g", + "bb343f745cf97a9cfdd43d63a492d502cee33da7a83215d2e5a29129168e4ffc" + ], + [ + "t", + "announce" + ], + [ + "p", + "0227fe07fce0572e529e753cf4e0eda5b56ee794919639b42b2e42d68e064626" + ], + [ + "p", + "178fb6dd67b2eb40c29a0ac53416c5fc9331aaaa35350ce9babe2820311efbe2" + ] + ] + }, + "events": [ + { + "event": { + "content": "AiXULte0WycUHT7i3Z6gb1bEqpYfjXS18Cmus3kfOGchXsAo3qV3sITBXbzixjDoM8xQdZX07PYVmuW5mi1sCzxzczdln2uM9zuaxMh7l8vxcWvPJ/maY+AiCQba1Iu6lUGB9vkIamJ++4Rik+A6IK2YIRjNfy9fN6gCES+FPJNnzRCgnAc3k5rD82v8DoUykLcHCYGRvPMxHtC4NW8wmomk6IcuE82fwbtywZ0Ap3KeEpNu0xvMmjTJuwY+tvgRTRHg", + "created_at": 1791467346, + "id": "6f5a80c8178a9a59651c67613a92daeb280ed0ce0177e8d1b4fe03d1783b12a0", + "kind": 24242, + "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "sig": "430c4073bd5ef7d3d6b143cce15fd6db9e5c41e417b0841743886e315fa5edc51157e4aff446b720e7dd1bdbce20a667bf1fca685cf6f9f237e35aac7d6c8627", + "tags": [ + [ + "p", + "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467350}" + }, + { + "event": { + "content": "Aqk5evV8FL128lapz7WHCQaCRCY2lpIVEYEMx2bqRZRgrUgsFW6hpJDZi+HxvDtDMIon+WLpttirGW/xkAO7yZVAzqTf+jO2VuEXpyXTL11UQbB5ojlhoHtDrRrrbwLrX7jID6WJmpTqKVbfWyriYS0iHxCcKwUP9XxwYw7+V2mIakLURPBNP1w7WKeWxz5luGshTH1UQivaTC2aTmeRkYvFl6orqhmoCDSSPbQBxIojq1eVLBZ999RC8PAmY1Mqd+ZN", + "created_at": 1791467349, + "id": "dbe4e339582006148742cfc3707f6202804d0d0106fcce8cf3afe7cce8e9ba52", + "kind": 24242, + "pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "sig": "ff37b0a8113aea28aa8b0b73930b8f7598ec3f3bb1177393ff98f879ba3e744d4f05f69dab5303bd10f9a11c3e77e6a2a51fb4532ebb74559b314b09b53647a0", + "tags": [ + [ + "p", + "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"c4dbf61ebd1b4977e586d67d70b7a7d6a3893a8b5a2d564e8c430b674d41fafb\",\"timestamp\":1791467350}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "334708a718be8bca0387e6e40f125415966c68252c00c6442755d9a68b041d07", + "payload": "AjNHCKcYvovKA4fm5A8SVBWWbGglLADGRCdV2aaLBB0HjRi+s7d/Z8TUiIVATMMfePgqQjBLYk4bJyUNgjadQhKStqUGAoWwrFVnEJAMZgH+lw2EBoS5oirinJY8itku39jX" + }, + { + "length": 16, + "nonce": "fd8634caf4d7e7cf1097ca12e3da159942d9bac841e01ebf63b8b852f897d004", + "payload": "Av2GNMr01+fPEJfKEuPaFZlC2brIQeAev2O4uFL4l9AEt41FPvJS+OFmX0Vt2g5W/KfwntvB585Zz45RraLMOkFItAjgoEb6hzGa/WpnsH3O+phKVGLpkWn//7Hl0GzpS+zU" + }, + { + "length": 31, + "nonce": "da33ab3992feb836cf1fef9c350863fd18785f7eab53ce40809aad4bb0234323", + "payload": "AtozqzmS/rg2zx/vnDUIY/0YeF9+q1POQICarUuwI0MjgsJXNQo37BzzLKKjr0ITp9v+tk72zYW0RT2f9YknoOEw2CZcy65bqksGs1UtaIOkDVlR9yBiQ/2Dg2Klmb/vQzKL" + }, + { + "length": 32, + "nonce": "38ebd2c49e44bcfb0970bc8b42e140550b64ec743ed035552bdb00165c083193", + "payload": "Ajjr0sSeRLz7CXC8i0LhQFULZOx0PtA1VSvbABZcCDGTPAADkkLK2EAbObPrOCeJusCKKN4egNdZ9YrEnh4WwxQi+S1oHEEyKYvEWEJ4utGLu1M0G916LI5MXhot8RzsA1uT" + }, + { + "length": 33, + "nonce": "6fdc2a52bf5e73a461d2831cb4df48f4a32caec0b89fd832d5c31cdab3c85528", + "payload": "Am/cKlK/XnOkYdKDHLTfSPSjLK7AuJ/YMtXDHNqzyFUor4abtT9aN0YYCP3y0HpV0bYcg2F9BLSxjyL1YEkTY9zSL9Lx6mjLMUtyEKJlkvQnCzgMT1z9Fu3zLL2jShmEMfLNnZVcsZdUjVSMLFyX/xJjw2n2mJDfqW48NKA/s/Ojw34=" + }, + { + "length": 64, + "nonce": "cbbfe9170917f2681e43ba1bb2908356b5ce4a774ff8eca7e8c8d83026b96306", + "payload": "Asu/6RcJF/JoHkO6G7KQg1a1zkp3T/jsp+jI2DAmuWMG5wmrSiyPM5pkaJjyestsIIyoRlnO7P8nyA5Dhxl+cvr9lzsSmHffxbdun3NYg0CzRT/5nSHn+HVSxP6G80tWB4oE0Nl3r+1TfPqkGbjRCuIxvLGleOn5UeBfRAtA2g2mZQE=" + }, + { + "length": 65, + "nonce": "62d5a7e4d36cf67ad1830c359d2ca3848236b5fb9bdaab447e3d2f15902bf1dc", + "payload": "AmLVp+TTbPZ60YMMNZ0so4SCNrX7m9qrRH49LxWQK/Hc4/7gWfIHlIxnM/ujXkH7SjI7S+06Gf89YV1Z8d/7Tr3epPWXtA+SAq2NzUuBxBekBm9fai1KE4ZTuLZfudtWLnjhqSzUlAtFHGbMPA9MlmxEeC5uQiHYd165WUWZfIRHxbdEjRQTPYg+7oFus1tuov283Aoq0Xbm4YK31CpHLreCTw==" + }, + { + "length": 255, + "nonce": "7ad8bd9f0730284c3bc0a20a413b739aeee516484df65eff2140869fb38cce19", + "payload": "AnrYvZ8HMChMO8CiCkE7c5ru5RZITfZe/yFAhp+zjM4Zcx3Z6tINZ82w/mrn+I8AEvGzB7OMDaCwk2/sy70i2HZ5SUzD47qWZGWt6Tgt8DnZTuqIKCAKXJxeZoMGTiqQAaWY+juFZHHmagD9F5tpxVNQ6L6wQIgYtJwsR8Np2FGm+O8Lz42HFIYEVnl1/um8eet450K05OjPRTGhvvuvF5gDzk460bDwGjxN6vS9U9nIBShRTyhvRboTKzUlbSvOWEMCKtjDP+qeo8DuiI10aHRmRQnG8bJrxLhl4DQt0aqMcXc6DR9bFEC3+nI+KOQzmmpcA+zVm4PyjDfaKH8Znty1/4nu8egw265WcyM9UjVA9hGw2ktH3ZdCXFw1KSQVJ43xt6aS6OlM/LRdZe2eU1tPChcXuqG9kgh7WIR7JpVd5b4=" + }, + { + "length": 256, + "nonce": "20994034195f0c00f465b8a249a57fb62386b061336f7f62fbcf585eb98e091b", + "payload": "AiCZQDQZXwwA9GW4okmlf7YjhrBhM29/YvvPWF65jgkbspWYhd1I/lGTyVzKspLLojGVzKxGX9mHARUERLg9BWDXPOul2ShcA5wYQbaXSQjeytBqGjzW1BySPoUVa6YvPH3wFFOXn/IDWNIekgucrBoYreqa5ej805g7sqKN18rA2MSGCAf9c2nK0bZhBQ60VcoLISSyOn4LCTCb6auUEWR07Vmt1Ra908nO+gZ8jPml4cn0+QiK0FsPYTiHML0SkVPNs31bfpPb5pm4YBxoEsyGWiN9QU/4WofJYs+QyhIXWQJ3y7YCO1Y1DAYO/iFKv9iyfp1ocOv3QRy4bJpTEB5c0OFnoWcanNDKuHjHAWG7BAuH4l4EAKa6VK/nYA+sNDOeR3dpAA4bQmeqntMVWny8aWfS4MmhM3CcHHVMu2jortg=" + }, + { + "length": 257, + "nonce": "6f846db2b1b3306c3c62c85df2d2a09a043eb361a08b1a641d23405dae220690", + "payload": "Am+EbbKxszBsPGLIXfLSoJoEPrNhoIsaZB0jQF2uIgaQxWhd7QDHrJm7CP0PVCV0idVruN1tWMrJdUdm9GIxCqWqQNOEN1vd85/z0f6Y5ggor9oabxfDF9GwfWZEGuDM8wnvv1TgWVbV4iUXUtCDL/8oX0u1JsqlDkh2tKs7xqT6/oTTZR2i8WJl/7pOej7FcdVLiLvTRrPyL+pUbBDWIvxJIOqPT9MKDCIzjNuyQ2x2M0tzucnhc1N8ThgAS3Wcf9LGIROZ89+ynVxqH15SOxkjywYnVDDyOnipjUPLMTQaNUqmv325y5uDG5QMkGsJibzE8mcOnEtPBJwIQlaa6rfebLvSgGd5dXUks4CpkVjndvmOILk4QTz201JKkP6LrRkCm6JxJfd8KZ6jWPOx4SXypsSuSXaGsMdzbEvgT6l7UAVoBQj3o2SnmO5ihvDJ4Sem+NmlQszDa6JqNKBSQ8C9GgCYfErPxYUk1z2xyV+8aQdkZDp7Hp9cCZGWMMKr8v0q" + }, + { + "length": 300, + "nonce": "20759fcd458f324ea753bb352a6530e693b415364fd51cdee922259593b32b63", + "payload": "AiB1n81FjzJOp1O7NSplMOaTtBU2T9Uc3ukiJZWTsytjUEHjF5JYUwZKjMF2O+IRw4k+0Y9I9f44nBpsuvExHDXvn3XhKPe7eSzTMozGBo8l3WYFFj+vMbndkB6FzFQLbd0MWKkje6Ei9aHkVqsc13PblP4MYj2nJrSltF6lQ5wo32TIUmDhqMle2hpRIsudi3Y8Ny4g510j731sZLzDgxXbh7cV7jaNzj48cl7zetEYUdehu+4XWtpoGBshpkTQIQX4987UdDPyAkC5+Sv3sK8hXTodmbLzZ4kuR3zOx3Sqe+GEO18jffziaG0DD6DwMQFfpeyRCcWHfSG6XhszsbowpwbcxwWUz690uItyqCtfKcSAUwhGsIwVr9CYUYC8ZGcaETl8NERHMNfbw/FzuijlrCGPvNRFcfIPBkvHtvL2lWGGU17Df9okXL/W+UKPy/Qmw3aQuYHV00oyAe3h0/pvM6txt0GGuLb4rulmFh6euL1sg23yuluiI1wF3t4RXYrg" + }, + { + "length": 1000, + "nonce": "aeb1d67705157852a1c1c2f953ff70f5a1f5e6370244656ca8b2ed383cde2b90", + "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": "06856ab277e98bd33a1cc32ed8a2e0305cc5be2b5c1bef91f490bb59fa98585a" + }, + { + "length": 16385, + "nonce": "c0874facd941d2710768ecd778c7fa2a4a11047815b34bbed71d3a209a935815", + "payload_sha256": "8714a5763177f031a6103d9a3494ca4f1cc7bcc5e6c72146412a18c00e5c2223" + }, + { + "length": 65408, + "nonce": "dda1bf189af214614c5897f0e262559ed8de6aafab903bbccb83cd4c0922e485", + "payload_sha256": "755955228d66f9f28c7dd3bc572d666a4ff408550e63c3fa03c6b716e7d6ce80" + } + ], + "peer_pubkey": "a4476f49b4478414dfd289af84799e1a0ea0fc6f3f763761be34ca8ef6cfd239", + "peer_secret": "51a6b2c6980175a00c531d74bbfddffcd4bedea4b21d498b6a88c6785523eed3", + "proofs": [ + { + "proof": "269850f7df3175deb2996ea53edc27143927f93801348619e3f4a4740cd425ff1e7e7b10ec0608116d4d7cc3d661439f92cf53b4382395e60dafb739ab3ef559", + "timestamp": 0 + }, + { + "proof": "d26774eccb90b74acb2da8df540afc7c09debcb07e5f60ea69ea326c7787524e143f6da27f40c1376865537687b261d95903deea36a5b5f76b26592669a0dbb0", + "timestamp": 1700000000 + }, + { + "proof": "192ed7db9be39e3647359b910ea2e779c39b122809372aa6eab8b42c633da0570e0da258115cac43f98719e485a25e666f7f4df3566a74a214a6e982c67ab1f3", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "a1e821e23570f7eb295e3e05b993e93efa1aee78af378ee7155364ac3535440d" + } + ], + "min_signers": 2 + }, + { + "group_key": "0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6", + "key_packages": [ + "00230f8ab300000000000000000000000000000000000000000000000000000000000000017d77294395518b94f6bbba8f8e11bb829b125350e23955e749017f26cbfc2a3d03fa5672c18c8701c65376ad0c4cd7e17b2f345623047ae9a4324adb4952fe2da60272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000024f34f112c85f208d449aad753e07bafee8f39424eebfdd8eb689ebd2da69686202ac88e83996019081807cfed4dfb726dd24b53eacdf27ee911cc134143cea29f70272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab300000000000000000000000000000000000000000000000000000000000000034678b54294c8a2e84a6f9298fc3a92d403591f8da8493c6340f5ba1c6b17500602c9943ba6a56c33ebd33a8420f1afb013219ac5ddc825cbfa521b4966362e469c0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000004634275d2fa8e12a6083a69fac8aa4301ea42f58b0ed57264e844ea037e05e129028ed3f1022a056bca7edbd0e3911ec6d932b8a00cb40765f45ce2ac4b307e16500272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603", + "00230f8ab30000000000000000000000000000000000000000000000000000000000000005a59232c3f9af6fc67dfb339aa356cb889db1161d22647f93ac777b8813351bcb03f4d941d419d4de23a1dcdc76431548e0c694b90f4d5bf13a41e0aae0b35270cf0272f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb603" + ], + "members": [ + { + "announce": { + "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": "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2", + "sig": "df335a68502c2c6181a5d8f3ceb58f61826516a7cd1aef33a2fb5dc4473d57e8d252f823828b14c14c4124d097cb14121d2fc8cf2cb6c293744a0b2e9fe21d50", + "tags": [ + [ + "g", + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" + ], + [ + "t", + "announce" + ], + [ + "p", + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" + ], + [ + "p", + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" + ], + [ + "p", + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" + ], + [ + "p", + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" + ] + ] + }, + "events": [ + { + "event": { + "content": "Au9nY07pnCqNjr3uaZiBNiWCJz3ZQ2TAX1r1ciR7XOvtfvhSTP55Mqd/tfooIUfNS0oTSLGgjrmInkBVii1LT7qf7kWvROITCuMLevambWUf3Zs5/zGxT1/p7aj/CtPPvxSNMZwwy4Yo28ZrmYNOdLZPnup8P3qiR8B1Pl9B87S6ic3/LeeSa21bJp+TGRn39hb7ObAg5Usq8BluCf1RsBhnmQmPxwxDffLsg3prvLnI0cSU6mrxEh5w8wZqewur0m5E", + "created_at": 1791467351, + "id": "2130f35ded64cfec00de339cf22a10f8f036b0702918a6f9ad8c8fe46e5aca22", + "kind": 24242, + "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "sig": "5838443285df13833203035670acf9a1f8a4efc7f8b2a6437e0f9d71d681e00ba393118db15afbeb17b3712d3f8a4e349f7e7d10311249094d3716a904e0af73", + "tags": [ + [ + "p", + "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467351}" + }, + { + "event": { + "content": "AhQManTTR10tHWxIfc0ily939O0FYrHBpChM/WvFu9Wd8oqIfsX1cN2B3GO+eTT99biFxiqlpUBq8UgaCUX29wnM4bKXFjjS4R+Sh9WCvt0yY4G1VUS8eFBoMfFOpTua5TrYL5pdWkfxsDI1eF8BaVT9HHffutfps3+Ou0Sv7P+Ea/N1Tf0Crt+aGGsCeYMBrBN3wLm1MMXeeXL9NlwPHfOi0M4LFYSwFGt5tIuiStRMRAjxTGypSbXQxg3VSuBMlGXA", + "created_at": 1791467351, + "id": "5dfee9f73da1d780ffb9ebb6b28927d345bc6a1889e6624beba23a9e6ea5baa3", + "kind": 24242, + "pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "sig": "6a4896d3ee07473f2e2b755a2cfa2e69698c4a6d47cd9160cee39965215c3ed2f112bb08e13dc7a570c71947b62c3b851c799a11ef32d6cebf9697504355072b", + "tags": [ + [ + "p", + "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"f5fa06b53159118ad2c6cdc607faa6c0ffeb61aadc38c2ff47c4f9e699d222e1\",\"timestamp\":1791467351}" + } + ], + "index": 1, + "nip44": [ + { + "length": 1, + "nonce": "35de5f95c9292fc722aade90df4b0fecdd4fbf49fe9fdadd24876a3eda5d44ee", + "payload": "AjXeX5XJKS/HIqrekN9LD+zdT79J/p/a3SSHaj7aXUTuz9p1RcC5wsm9hF5Rf090IjPCw/8ywo0UQz9pgmMxX2AG6gGCG/fPBS+akdomZTvY9Az7TrA1iSxsl12449dJUvOF" + }, + { + "length": 16, + "nonce": "e93d958af5dd6cdfe73370382267f2d811f7f63fcc8e81d7fae888daa0e3dcbf", + "payload": "Auk9lYr13Wzf5zNwOCJn8tgR9/Y/zI6B1/roiNqg49y/e2GpnKM0XIWAkPaeTfi2JIkFBc5P13+RzyXk9qcEzwlLX1a9ksN5g2wGlEdDrBsgGKyJZa2B9jKAZzUg4Skflgw7" + }, + { + "length": 31, + "nonce": "53ffa6c0cd2fbb0948dd600605cfa2217089270a72d46c1affe2b99420533aa0", + "payload": "AlP/psDNL7sJSN1gBgXPoiFwiScKctRsGv/iuZQgUzqggQoatyMD6KgksddMJaA7FBmJDhxIYtwVYa3JHwp2JctizzgHh9J4RPoqlc0v4JFx30TCm0iMiZyKMKcZAI7lQShB" + }, + { + "length": 32, + "nonce": "dc6c91f26e9727c63d456dc955671f8a3ff8c737def22bc80b98218f13abeae3", + "payload": "AtxskfJulyfGPUVtyVVnH4o/+Mc33vIryAuYIY8Tq+rjVoOp4ZoUxttg9nFx6OaayM0gXCYrLQaSGcJiJN8RtDa8+qe0a7rzFHXTGNMkLpISSaPvXSb5P8pzLAjCXlUHe2Am" + }, + { + "length": 33, + "nonce": "2f53060be3a6091fb8ea2c200f2726eb042d46c9322fb4c588c43cd7ad35bf3c", + "payload": "Ai9TBgvjpgkfuOosIA8nJusELUbJMi+0xYjEPNetNb88sIiGzPTZmh1MW+b1TaoJvKdmTgAwJ04P1zh5HurmH7CM5lV9m4JTVBB2DPQV9RtZR++3C7OpXr6jxA8iY1PCn0bm855OmhtjkCRP0F/TSKQonXoq2mT4ATD9TuPFw4Z+ef0=" + }, + { + "length": 64, + "nonce": "56652b68bc15a9ec751dfcd5b9534ff2982b173472c1e851f925074738c0dd9d", + "payload": "AlZlK2i8FansdR381blTT/KYKxc0csHoUfklB0c4wN2dfGTkupKzBFHVb55w+IdRCuMdmPmeKeZ6TxtcizvP7CpgNdRn0nFObeihoNCMr6A3vQwaOhgOyXm/UmXWHgCvU+XGQkX+N6lNgp/O1bA3B5YG2HRIDxlehdBVUL/iqkXGJdA=" + }, + { + "length": 65, + "nonce": "e19794dbbf768d6838ddab2711eb037a72656fc34a4869f63e605f2451c2f09a", + "payload": "AuGXlNu/do1oON2rJxHrA3pyZW/DSkhp9j5gXyRRwvCan0dXrrTiqhXuQacUdu2TLcE6p80KNeHuwAbJhZMHwhq41EZ4e8uG2uA4b83tTYsFzbiXtj3k+NzSxl/Mxo0+r6+Q+mxggMVfbOaNr8GxYzfGlXKh4fAtvg6F9A7IF3MkAK+L3E+31euhsQU0JwcGp71WM5VXsLjQGGan5EFPTsKlIA==" + }, + { + "length": 255, + "nonce": "a7c97adde5a52126d39edb1dd425756d8d49a6de7c1afb36731a18ccf426ee1d", + "payload": "AqfJet3lpSEm057bHdQldW2NSabefBr7NnMaGMz0Ju4dDtkUz2QGWHYn51pKZR+9OgEjpnjyAPlGxvgyRzY5Jytd/LcTPmchARlep3TeUSm14CgVMIhcPUyZCX+03rKI6nTo6toG+0hseIsbsTkydRAuH17l8HXxHOZAk/FWRoqJPoltu1jdKRlaCLGCo1RVMa9eyTEsYku8q+5vJSU5obtNNCOo4YPCtuhw105fVnyW5x1a5SGniLjJ3K/miL44SNYu3dedDUOgDnvekwRZoV+xhfKNU0AppyuMV2uI62XfzZaybti5bgV0EDDfqz8Wd2YLPnmeKIe3vgoMEfsygRjhv/Kzkz/qGrXYqwsCjjHbFBYka/uhxnZaodjw/0dLZKF3KEpwnyzyc9A97RDl/9gAoXXwoMfKaQVIhVnscErv8zM=" + }, + { + "length": 256, + "nonce": "9dedded080b305808a08622ae5d038a764bafa0b95047827047db26141184b7e", + "payload": "Ap3t3tCAswWAighiKuXQOKdkuvoLlQR4JwR9smFBGEt+q/iovvILiF+mMRG4zLWNjfslOUkf2cEsLyEtYFz0BRg43AgJEoKLz75KQkRO0WQwkXrfE+4hhagl3SaIfzvZfAImw2+fN2AlzuOCvBDQBKTGwzndmoTpOr7rml3TQJx2JspFlGUWM6ca1FQA4jiziu1SwVq53plOow4Wu3Dg85LNIJmf1+dRFY5gr8pzpvViCnc7Cs9finjZFtCdWBU5eIfwNhZmY8R7O+sWKHlQ9clhQwy7W3PQc+sqthdhGIjrVUGHftiWotd6WMhkI6XG/yGkFppDOniWnhRLjXdo5Yzdbnkf1+qOZKBilgTCEOrzEaonUFUWkGShW4pmvjxWb9fQeiri/LL3dxoE8ZfJBp4Sx2VUMYLupNU6XR5F/5AvdOY=" + }, + { + "length": 257, + "nonce": "9ef8f1a39d116fd891bff7abd67cfa4f82be42d3ac626d9375fba2c8fefd96d3", + "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/N9oOhAMJA58RATI7lwPIir5GWZv9PqUKf9K0lJLZLljNWJqNnHBFJdVgS0Gv7PSZ5mQ2LYhyOpzSDyrTf9PMyXIp+SyRqRJGvsExtNlbkKBOTLPxGwJG12YxgDg6Q+cDRwfM70eJXGKc1t0m5HcgXvIi2K9m4LascSy7YdLZ+Lt7NLQ5JO/WzG8kY0k3pY7Pwe40d1A4nl36bMUVO1kxlHeQmhKob6DHTdERz1fhuDYmbmzOkoXljTxMxuWiIlBlGCihqcSyOeXian59nFG5ax8tSV8XGCHoCF1xga3miFKaIntE9F+j+doVKZPBpBUZfVlj1SKnEAu/0DP3WVH9W56NDtG9cnHYpj7sLC2W2eZ+Ag3bb4Uc9tQtMj4z8bbQvANn/uSA7l7hpsLgB08kzoZec2oMjy2KuMy7/X3hoC4C0PrEAPN1R2qZjdXKr7uSSMDkI4xNqYrhVchCexyCoRs9TngmG5/0M9iksdTrGd1JKweMQjKq" + }, + { + "length": 1000, + "nonce": "d79c54d46de6666f32660ed419ad942879f75ead7edcffe0912a7f0a1f199067", + "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": "b455b2200631a277d49e199650d1e951b662df3990f15832175a06997a6304f7" + }, + { + "length": 16385, + "nonce": "46b2f6a60d194d6a689d8d0fe9b7c72c79a48c118f90e5ad14974d9e107868a4", + "payload_sha256": "db9f15d6bbf9d70fae598024e014f483a864e3d86b8901b19512e6247690fabc" + }, + { + "length": 65408, + "nonce": "c3d733c51bd5c2ffe2b8134ac24cbebda301d40315d3d3c09860b048905bf333", + "payload_sha256": "c519651fed8c788bd95fcf4ab2bc9204f9bec06f41d552e10f439fabb1bf8f92" + } + ], + "peer_pubkey": "449b59ab38624c14fc2c8129825356c309ae89293ef5d6ba4716d9e60589caa0", + "peer_secret": "968b7a8f13cd22fe46e2694bd9324845bfe604d7c259011b130ba45cd2c3d70d", + "proofs": [ + { + "proof": "87d9b55a7d562e5009f2293e02c3ca28ded370b0ae7335b1811f98480b600839753b0a4d324c7658953d57431ba9355bc833ce5d34bc444b10d6435bb3ef7e7b", + "timestamp": 0 + }, + { + "proof": "d65c0ce0c0785d4db4c05387be005da7d8ed78a375e400267f755ca0c906563dd0500df802a1f59898bb94faaef1cf5bf4e6fa546530c508d05d24e321fe7169", + "timestamp": 1700000000 + }, + { + "proof": "031e6d995070c7ede12581f2a12bc8ba059d35ed33446308698047d37f3190be555b73949b4e62f0e82e6e9515a1481687a32e07f37b50ace7fcd09d0a74da78", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "5ca51cb2c8fe0cd6dd4db7e4462584aa41becd37d00386258ffe44ab1b04a3c2" + }, + { + "announce": { + "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": "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2", + "sig": "06156de7fcf4e6c1b72bd0d9fe1d20fa36892cffd66fbc92f2a51d3db2d4d778130971b47b871a0423c3b4321a908090724a73d2ab7764baeca77fac5f3ee106", + "tags": [ + [ + "g", + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" + ], + [ + "t", + "announce" + ], + [ + "p", + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" + ], + [ + "p", + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" + ], + [ + "p", + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" + ], + [ + "p", + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" + ] + ] + }, + "events": [ + { + "event": { + "content": "AiiTQCXqJUJJ6GV/00qaWzpRa+IiIqVOymzOE6dxFIXs69KpI7OBpIYvkO+aoNXLASSysVYdqzTozFKaWzH4KvU5xy8aIFoyFOm1NKJFed83Qm86vd6TX2RMf5eFpdmmIxEBm2TaiIEOsPSdlQKaJOzbXuQ+N61YOScKnWK/x6t2JwQDMsUwGhkIuNWcOjYpBduS3NuEwCJH0YOpARJvNSAk1gSLmwdpcAk+yNAZDjw50nFjm2hAz9jEhKpLxOI/Jlo6", + "created_at": 1791467351, + "id": "b0a1a98262e35b32e0b277fefc5b8816fd5acdd1f88a8dab5bb981dfecde86a6", + "kind": 24242, + "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "sig": "1685e8479e4fc326ea373bba819fa2a92c23b74f74e6b30ccc420166b7b301025fdbc6ecf49b407347eae405deb76fc4d09102319bc7577757ead2aef96363f2", + "tags": [ + [ + "p", + "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467351}" + }, + { + "event": { + "content": "Ao1xvEggvKUDodyy5NusrvCZ+lPu30kxawJXWKcnHHNEXDi0Vf03RwpdOLxMPXT0C5KJtUM7o5NFc6N++OX6TV2l+Gg2gGNuUJhDvJcUXh+HVFiHblAQzPFnnWT175V6sZbrvtFQoBuCibj8SSqJluheoyOg57CMLlZnM8dhVONU5DKdO/NB7VVe/rKWdlQQNNfiMec+IkkGd5vNDIpqV87rgRxHIjXMYmn7lYqz5Sx3LSRnTzYCeAO0TH9cA7y1ENVj", + "created_at": 1791467348, + "id": "5db3a1a35bc10e155b41c936ffd616e879da27676ae6537363e5794e519235ae", + "kind": 24242, + "pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "sig": "d3aec257bc3499df635c6ce19fdd786fe82cc56fe0f2cf9550dabf484cb78b8b3a54f81d11d1ba5ec752d8c1c99963401f4ed60d47469480ab6487821d0ce096", + "tags": [ + [ + "p", + "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"b40befa0863149d4c89e53c7b01487708fe6fb3f765f7080f63f90105cd18ade\",\"timestamp\":1791467351}" + } + ], + "index": 2, + "nip44": [ + { + "length": 1, + "nonce": "c7cc4ebc48fcf9ea4b95013bda8d13261f64aaca9cbd1a04d35b7b08bf9cf24a", + "payload": "AsfMTrxI/PnqS5UBO9qNEyYfZKrKnL0aBNNbewi/nPJKDAcG8cUBcwcfMPjkCpOuuxXomxtLH4KdnkIgLzhhjY3wbo0v5hhu3lTviuMf9N1bULZWMbM/qEaEQp4dOjFi+UP1" + }, + { + "length": 16, + "nonce": "21fe3bc66a60a3ef2f02ada9c91b6b742f816b5a62fe2826643f49a2ccd13d93", + "payload": "AiH+O8ZqYKPvLwKtqckba3QvgWtaYv4oJmQ/SaLM0T2TdBs2Z4uzw37AY4pnZe8AgC1cVRY/jvAA+QYOaSpjchBfbcUnVS/EtEczRLRMT/KYaDuEqvj8Ai8n5AxbivcYClc+" + }, + { + "length": 31, + "nonce": "ad8d4a308012ce84b463f1c0fd2896a5346f777d94db69fdf7b4833bb1364dbe", + "payload": "Aq2NSjCAEs6EtGPxwP0olqU0b3d9lNtp/fe0gzuxNk2+48UtpyIiB/lEM9Ul8nvRMe+60tDdM/qn6286fNSDOMzRwGv8yVZpDnXPlyHPbHaPBIT7NFPckkLqchqHaxUPcDvJ" + }, + { + "length": 32, + "nonce": "f23e86846416e77c79c013877140d442af1c415f97ba08eb31905803f86eb903", + "payload": "AvI+hoRkFud8ecATh3FA1EKvHEFfl7oI6zGQWAP4brkDvu+rr1+kcZlwwxwXFR0/OWPHhbdRiojptyCFZgex5G88EKKIuMXVPPdja71kOdPB79tIhqvL+lyKsq7vbelvrrLN" + }, + { + "length": 33, + "nonce": "d5353cfe6c1f62a506e97593886195a2d6d9e1dba2c54014d06f48d732448143", + "payload": "AtU1PP5sH2KlBul1k4hhlaLW2eHbosVAFNBvSNcyRIFDuxZOA/ygkkNeTestPvK/Zh6lWS2GjFtjKlA2aSKpUj4niAhSipmCZE8//ZPR7f0dcf3QzbjqZdQZsBUbmIT3sB3AdPqprscgmmRE1j7ZgykW03080pI1bWwgqkepZFl6Qy0=" + }, + { + "length": 64, + "nonce": "12abfa87f5565130cfc5bfcab930bf2116de8cbc95e5d1fa03f71c396f0cd19f", + "payload": "AhKr+of1VlEwz8W/yrkwvyEW3oy8leXR+gP3HDlvDNGf+tJU8l4f+xhUUDoXC6Dul/Z9D7VCU512rXP7fz4rXBT2sZSEzIFUEcCWq8qzbXKrVVmF2AfJ8lpqxlmnq7yfGQv4hYMeMa5l3SzM2gQfNgcDf5Bw46pDvr3gkHf1ya6cZHk=" + }, + { + "length": 65, + "nonce": "1e1459b28fcfd4d6baa69fd2641112cd2098058c42adb209ba85633b85618e6d", + "payload": "Ah4UWbKPz9TWuqaf0mQREs0gmAWMQq2yCbqFYzuFYY5t4R2NXRKibTsGclmuP+cn2GIek4TnYJB1APTXBqJM7i6ie1rsn5BNvybyzyQ1ENqSq71THdPU2cclQ85yxvMuhjGIQXpMTMx5ncoJUd5QFf1rBvyitL1b54JMceFvAk2Gfz0VotyAyl0nJr/IQtKhlSBmoXb3PXJSetFMAsLEAvUWXg==" + }, + { + "length": 255, + "nonce": "335abeb1a24fbc00e9cc5f89cd10e86ca5bd6c2258359b998c7c6df0e5aa54e2", + "payload": "AjNavrGiT7wA6cxfic0Q6GylvWwiWDWbmYx8bfDlqlTiyYZL3yx7qjzbAHozgYg9ob+xpfWWrxmkqkkhitYk2M7GpQVkLVP184IIS065mwP/eGS06smKEzhtRg6jndwS7t/YPapvG0tZk6qQF4np/d9d7+Cvo0e14RjgAfyxP6aRJ3awp748dnwhqFdHap7R6tBeuc0grLvoeQhgug7nQ8ERazKqNOWfijpbjAHjdtZz5e6Nasmq4Am0dnuakX+77ZGMWjnoptacov/8B/1vwA9MWans5dFf1TosgklUOHYHL6AdWa7MOJ2dAAWPONm3SdXMVc7ov9b5p4+FfqiG5l7XoZhlNMsLEsYgrqKQbW1TnwOBRYggzRrD9uCreLk6OkOyB80V/ciddDSNfeAs3r+Ou9StEeYXIF8XkMI7RGfgQjc=" + }, + { + "length": 256, + "nonce": "a003d16e5681621eec12cd4d490e577083982c348a9ff0a8c79e5f49b8daa588", + "payload": "AqAD0W5WgWIe7BLNTUkOV3CDmCw0ip/wqMeeX0m42qWIcXkiNdcATXBGaANkpBdIHu284Meme/+8851h/sxjwhBjrS/EJocGWQbOgfQSDXCKSg2X4NmEF2GDoiqLvniyjJPnOpqAFRZ2a3KJ5LKvhcISIN0Uai62zctmjDOIRPx8eT0iYxPoru6jKICVIsHgfdDm5QkbXSjgbsHxvSPue5V5TbeWoJVD2RAlGA/oHMWZaDINXS7SojkbZ0/X1DVd7PsqhU0tnHYxIcHA1fKUeUxQ7XczqMFCgJWU+4LUOoj5P24m4T9TiyhrfjDnDU7CPIszmRz8JAchecljDEHq4WGQAMCDjWqNKxMqi68SxKIC7pXWP/SoBqos22JwzSjeihjIEU+qPBnpHUHlUjPPctZM3EM5+AxGwjDo7bQL4C4h6+c=" + }, + { + "length": 257, + "nonce": "59605cc1c103b41ac91b2334576a322015bd170b5445ccff345961458078aae7", + "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": "As9OEiEGD3NF8AehsUdRCnGN98gSuttNQlU6KgG6kjgl4ADubizzwYpz9/SN5A+/50L8xWcMlhc5bHwviuAD50b6L0rVkbXPV4EREbfX/c2M0Ed7HiQKQUglFm2HADbPaWGOqCqnf+duifaEoYyeSW7G/7fjXBl+pPYpb3GVTju7NTGzx3XxlGVXiuE0OIh9N8jbzRUVYLan9HtR8vGEr7oKrI9jAjF3hVmFbKuwk4gc1NrtCFp8qczRuVgFZ/8Qb82+JRo+hF0fxj8KpMo9eH3Zflk34RtQfjRtSLAF0GDIHyHC+ihbKGtWGR9CgbfGfzU6/DK5zH+v+1Z/ftkMTAxL6Q8FqLtPc9CPX90q7Rwv9zOXHzemk/oQwphBLVM7aAy3jj4AXz20YIiMBc2okqQimgHD7F0DDect7v0JSqVHadnSCMNXud8Pw/cKcgaZND9NwiOC3PjV/2dJV7vdEEBssSBc4oPe4iD4lxJVOY7bMCKjG9bIQti8h3PO1SyYjvj/" + }, + { + "length": 1000, + "nonce": "51d3925d76bde2b2d53a2b8c285f14f1870cfa3264c6c209ba84d0758c3a2249", + "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": "47122229feaa82504d319e6bca7728fb0ee75b895d71cc1b59b26eb548c923d8" + }, + { + "length": 16385, + "nonce": "ff3410c7c0b3ed2782d7e27ec7f2b16ad2716a8d0ba1506cff2717cea83891ff", + "payload_sha256": "de7c390d74f9f94155fea91eac00cd3d9b4f33b564712212151c1a7df7e661e8" + }, + { + "length": 65408, + "nonce": "bd7fee018080bdcaf386916c733834ada1b438b8341f24dd9328cb983eaa6a94", + "payload_sha256": "f191268880e0b4ec2539ba22e3976435284273b564f25a625563ae419558cbf6" + } + ], + "peer_pubkey": "ebc641aee6d9c3cf69dceef893c3d2c6688def1d08d376d6169456a25e2a676d", + "peer_secret": "b690c8608bd3d48ac4f6023b22139fc2e622dabe720b0699df144f3c5f279044", + "proofs": [ + { + "proof": "d0390ab92a4fc484a588938db4cb44efdaa3dbd31f3cf0f9db99ea8f82a97415a6ec3e3e9c1367bd2d7f79d621327f5daed5ed9feaba2bc7fc3c845f6c75f1d4", + "timestamp": 0 + }, + { + "proof": "5058367c745acdd8c634acc4f7b0c569bd738df876cb2ad0c5480c73d605885405b7cfbe247125e7651a2b9f5b98a0002be2ab68e09d230bfc210a1cc3bc1363", + "timestamp": 1700000000 + }, + { + "proof": "32b4f8e6d029d744ba59640786ea75720cfc4aa7a6c411697af6bec413d3f500c92e4b3f0f7e5cb027f5c440632585a586ced4e1638a5bdbd3de55253959bda1", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "a26e929bddf782a13854ba8137c673a89c298627be731efc4f4368aa90d437c2" + }, + { + "announce": { + "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": "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770", + "sig": "8d91b58bb44ec3bbbe74aa90a7619084528affe04c44b15d3cf4618c4ce39433f96e6e07ae0565266ee97098267aaacee11a161329c6e785c49fd4433cb06f7f", + "tags": [ + [ + "g", + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" + ], + [ + "t", + "announce" + ], + [ + "p", + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" + ], + [ + "p", + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" + ], + [ + "p", + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" + ], + [ + "p", + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" + ] + ] + }, + "events": [ + { + "event": { + "content": "Ap7ohjoF+Nc2ZA33onfl+pvo4nKPAg0mIGo5HC1NhT9KbvIfG/ETTpecIkj8PELi15AvPSXk1SyQfuCuv1hNd6PIYkAzaRDkFYnNLj6fRcbabMkAIFkQk+E6d7tWxh1j50XPbfHKgnYjsAUgpz+xy/K/vIuAJeRLgkzNBGWwELnsdaoc1Aw+sA90o9tu+y3dtP5fyELc0zrZwEgFAOdRDdOzDLgFjbrGsDna9seMb9R1ZzVNN7ExCWcERkXPCecb8z5Y", + "created_at": 1791467348, + "id": "d2f90541bb5c316c06dcaf9e5d555575837b1f7952bd58b86c832cd6f216a3be", + "kind": 24242, + "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "sig": "28d6377d1453c0e184d3959207eccc407d6575f7a8c058a103b5a5ee77ee2132120d0556d281cf439da2440ab7cf9be785845dfe13dbecf8e21ad12aca377a4e", + "tags": [ + [ + "p", + "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" + }, + { + "event": { + "content": "ApaCwoMEa9aPXwwezpBVcuSjDniF77ckucw9c7Q+JLQyCFz0tNc8AAYgycqzyvyAadH2koHHayKa/MWcEfRo4MQXFFDHaqZreukVxBSn4CK6VidFaHrwnMGxkMZTl2f4WysDTDe6DaUrTIhmR3MDQ7c+rdFiXEePl/VzFcoorHEf7ZdBiV2NZcJkm93fIX3qLvAP3CpOerTOKzQQGyDwhZYLC/AOuI551TJ7zcV6Rcf57OdVQI9WIJrZfcDfG+XfHOTa", + "created_at": 1791467349, + "id": "b231faad2c3c910fac7daaab86faac51cbbf5fc9f8c4b25872e1f09610546501", + "kind": 24242, + "pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "sig": "5075d4a7a14ae402e6186a690098ad0a70e95ebb9c8467b3650d9489156a84bbbd6f51277ed06c5003ff3905b8a07aba7784fafd2db174f2e9b7750f192e9daf", + "tags": [ + [ + "p", + "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"0c7119dc73a14a92556301204120610a3fa5541e530bcd4182d8e9b45b75a21e\",\"timestamp\":1791467352}" + } + ], + "index": 3, + "nip44": [ + { + "length": 1, + "nonce": "730dd3b666c8ae9861d43b4f466486879373c9e8434ae346724d954d64370640", + "payload": "AnMN07ZmyK6YYdQ7T0ZkhoeTc8noQ0rjRnJNlU1kNwZAhDJebKhYGMJ/N7T1YU1SEQSGbl3BzFrajMpHGjLqziacs4UpByDMApY9Cwt3V10SUaDvsuPsWHuXiNs55f9D/vRT" + }, + { + "length": 16, + "nonce": "556a283834de1c0f4a570705f349c063225841ba4db5ff808f39e0b8644664c8", + "payload": "AlVqKDg03hwPSlcHBfNJwGMiWEG6TbX/gI854LhkRmTI4JGEIV/IfQLjtzFBKbQmUj3Pd8xVO4zU+i0k2HEFHWJie+xRVghRT9Re9hydBiQDjgV7B2iSLdZdsgSEkc/a/JBU" + }, + { + "length": 31, + "nonce": "b5f284fe48ba8a0a95bf23b4f485a14602367a18735978e396f9480c066489be", + "payload": "ArXyhP5IuooKlb8jtPSFoUYCNnoYc1l445b5SAwGZIm+lA2QarSs2bD5j65+MNtnQvxJbEF0uaQu46p/rUgaDUbAGH1F8cmAobCXAYuurGriDPFlkC3eTf2LtK2Q5iqOoBvr" + }, + { + "length": 32, + "nonce": "c8bddaa582eece36e64e0b80799bd6df095f3b1d42aa275d787fb718cd15f985", + "payload": "Asi92qWC7s425k4LgHmb1t8JXzsdQqonXXh/txjNFfmF/Mc2Nq6mwtUGXe4K/enSCY/6Nk5/aCUb6KnpSIkZXKepuYQ1Tc18Cdl9Rc8SyvaNYb7uu2fx9gsl/h8xUgrLQWzJ" + }, + { + "length": 33, + "nonce": "993bcd6fd5457832884c0a4ac16538ebdba618c0403b4b49a1443571fea23027", + "payload": "Apk7zW/VRXgyiEwKSsFlOOvbphjAQDtLSaFENXH+ojAnM7MNldpebEFE+/UCGPqkyprpCXPOl1LDVWU9r8uVQD4CCT6MMmseptH7o4kuZU7lUvxerZzDujI/ghbcMdsMqWOZ9hvifmOQQap6NWOpIGabnHapSl4YGIwHBAKAB4x7kyg=" + }, + { + "length": 64, + "nonce": "a386047bde1ee137f258e3957a38540788805564a7b594514ae826e618d4321f", + "payload": "AqOGBHveHuE38ljjlXo4VAeIgFVkp7WUUUroJuYY1DIfRariI/U64SBW+PK5aRdroADeF4+vRPAqWbckM2gq01Lk2kQJNDsKt70npmySQwP53AKEI2hGe1Z4y0sPGvNHd/NnKHbRoRy4lLi6io7vslwFGJsSaGeA5U6mA4CEXec+Odw=" + }, + { + "length": 65, + "nonce": "da1b84a35ef0e40c6561bd9024aa3a6ed6712126de12d1482169a2781c44fcad", + "payload": "AtobhKNe8OQMZWG9kCSqOm7WcSEm3hLRSCFpongcRPyt+6KiqLttNRsP7mzwstyT6QfgFRWtGrAsj+037VuKA66ujCuhURs3S46PH9upiDYP//UNcHr5i05DHVgB0+auuSdBAB+akDHQ+1wr1x1hhvbnewUZbAZDPngrjJmtDfLUlzrcIQhGgMgzFv2WndEATaOQR5TKYLlEFT00mD5pM+tgVA==" + }, + { + "length": 255, + "nonce": "a0403f0ed608ae7311dc8ba0517e20f787443f0f611c740c00208bb68c88b387", + "payload": "AqBAPw7WCK5zEdyLoFF+IPeHRD8PYRx0DAAgi7aMiLOH/wqPzDM1CyLEklFCOAjXbr0SZu65DJfIk7Wmja8u49jqipOg8e914wZSCl5QCoE8j6AtbQFk2RQdYHshJBwUU3vduNnm9AvR2jpqOLaOv5aW3DQZFt1pOcUvlLSbbPs3k3payzH94yjnfFyRIX7/Gwbb8Fm7ppWzr+QGUs3F7WXgli/VdUgbYyRqJfS4XTUlDT0m2JPapA42bca37NaDkH17wauWZpuxxuUHWAl1BrNJx1ApXeZjbGv7eoBeawZxTE9v7WzjMaVMSbVa2ANZNW72Ph/QftSFzMYhdO/+CqOdsRm+phLd1zHIM21wsncNlmVxVK5OrP9S1Tc29V5AIrdkzc3mbqSfqVR1nScr/Oeo4sDnexkyE13AtmMMzlOGIq4=" + }, + { + "length": 256, + "nonce": "935054aebf3273e871dde091e67de813980e584021594516f2997877cf65a8d5", + "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/hQ4CzYkqIc9AnHEQvX0CCl+goXYq4PFu7540AEXlSovKURSlyWsc5SgXKCQ4louG2MF9y/MYjy4JQmPSEHwFJxcHBNupw2PcMzUbdPjARLrDVAAL+IKFnJ537+wXCqljBS9drIplJq3mCtGeMIaevaqU3vI3PzfhHA3ugcr5v+2wU574PVIktyiZZvT7EIYqu6lv8wDklkZ9x1vhZmYgrl7MTvypBRfLkOZxXYn8aiSLe1pEhlZU/+IAEzIG3ZY2RF41SELn7JHDqjJagrivCOQbudfXTganLzvWaNf8zXOkFo+e1MYM45JN+ex4E6BKPRQPGAXqMaQNwSaLy2aHummA8znzkRfjCyimrPMqTjMx8fPdqcifQYTHonWEWMSObK+a87HCQPlKGhXT7yWwqREFoIE5wJNPxQELZuSngvKfYaGLJk++q3YuaWceEI81stJIllFbQy3pmh4St6jLv3Lv0Ve5zEMkdjXxEN" + }, + { + "length": 300, + "nonce": "61856bbf0d107107402beef928a1a615b4584a42b40be3b8ddd46fcd1a1f63f6", + "payload": "AmGFa78NEHEHQCvu+SihphW0WEpCtAvjuN3Ub80aH2P24h4kTHFbDIo7yYmgO4nzPpPiosKhYPCC/cl56KQcuYITEP1vBK4gzaL23tpMG77qPZ4DgPe937zrxURXI/WJhA0ZBnqrENdTgDt9P4lQqCxtgYb709rJUpJFoJH69q6GzT6kM4w0Xo0F53bcHBmERW3Rw2kdNtFB6S0OIworrQvs98qiiP2Kk9RvMoheV2J+qOB6J6/n4dYvYGUjMdLIugml1M+m7TLmJ/0m5344XbwJzLDJX/epCYOR6AO3PpJP//DLIMuRtXxlde+BACu9WQdo51TEdjoSYx+BeU1RPaF0F/EFOpu6LXb59TswjWC2JSuPfOLlHO29kozkzffv/JD0P7NZARZ+4yu4lrQoN4J1hx18U64It9pPU7RY9c1TFc5sjvyXoB6bzYRVZcOZG+VT0G57J2aPVl25Ry5qoIGfOmlGQnWPUI6xDdwHn7lSGsuSAjOGdCSihVc0hQQXWHIf" + }, + { + "length": 1000, + "nonce": "440f1052d4aa459143ebefab3ac9f1862b83b43b2a30e9c5fe118a274b1dbf40", + "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": "d73bb6aec4c2a1deef850dee38f3b5bcd55ae4381b509857762e5e0b13f1a2e7" + }, + { + "length": 16385, + "nonce": "bd61789fb7f0238be2ea43d7f96aefa11304a985d41b12b9c5b600316f6f78f3", + "payload_sha256": "4565b451e59a189f82aa27ea1220a4a791cc865a8ee8009fb924a66a35dc5b4f" + }, + { + "length": 65408, + "nonce": "763362642e9d032d784b56997603b630b884209afa1deb539b2863f1c4d62167", + "payload_sha256": "0f568051e9d26fab8ebccb00f7342ab00a6b5b87ed047f49d824a435e9f50464" + } + ], + "peer_pubkey": "c5145a8a172b571f159ea8836b22d3fa147ae31ce3560d64afd8542d23acc0ac", + "peer_secret": "9564324958c336ced3cbb1d8892a8fc5d89604473194e457a2fb400456e6a7b4", + "proofs": [ + { + "proof": "eec3032e22299f9bee88ce6a61f41baf449efd4372a98ed428070c07d0ddfb64994d16b6f293e615b4a1fb5fd398b46e978dd5ff6ad614c9c39f536853cae61e", + "timestamp": 0 + }, + { + "proof": "9bc7e9b44ae1164b19ac424393b3aae41eaa70dc099f8a8bf04fd2293a96fa6cc21c0a3d64e1c54cb6396dd1f480484555cf9883c9f730e92237e87c7f22641a", + "timestamp": 1700000000 + }, + { + "proof": "da6af2986b1127b12b6c2848aa3865489a702ddfeac3c0505765b72aba9bd721b559145e2befe6b59fa38afb3c087aa58cb0dfdbc73971299a1303594ebbca5f", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "862b10bea36b779ec84aa6600f56c31a049d6c4805e1848801cd57175e978770" + }, + { + "announce": { + "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": "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43", + "sig": "6a86ede1372077a9c55b159bf01d0f61784df3da87925a609c17bf2ee4ae557d841db52da821bb3d774b3e0f8e61199de166fe43e459de05b27afa697e3b161f", + "tags": [ + [ + "g", + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" + ], + [ + "t", + "announce" + ], + [ + "p", + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" + ], + [ + "p", + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" + ], + [ + "p", + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" + ], + [ + "p", + "2d051e270c7e443e0345ea1665c4179e9982602cc986b1c0746224daee9b3d03" + ] + ] + }, + "events": [ + { + "event": { + "content": "AjpswCmqaz7OVxUFmtR0PABD3yy4zZ4qpYwLlHjFjV+LbIwUKego6A5h30KmZJyfU8mYgmluZTIz8zzceAJM658J2D8Q9YXcAn0Yn7093wqFwrdEBPwjpZ+jOmyD5GLvRgSghg6DvvExC6uogY794bDqaf8y7l17nEZbV+e5BJHKnztGk0y4CV7S/dXixKiYHXdd6fLxE7S+U3BKQZGqCNZn9ZGRaYeZHdtqEEI/+QoJ1XAGxzTe4vvhqhgyxZJ7KCiz", + "created_at": 1791467349, + "id": "aea04282f72fa64f68eea619630d6c65c86f452094e70ab90eabdabfad6a6d0d", + "kind": 24242, + "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "sig": "cb410a1c5f50bf1615fa88de6f73ba4f9e51d923d94496de82679046b3896db55a8b5d84ac227111095c9c4e475a32dc9d8768a1aa510c3ccc632d78c2a4b00e", + "tags": [ + [ + "p", + "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" + }, + { + "event": { + "content": "AlyK4Sb30XSLlp/WmO/E2DCzTEr/piAJejQWYttsOUYf4dbDXN1CopBrKfkLFyI4S/cffde0YPdL+LbtY6a6flE6AOzK81T7QMYrWDF/vW3M0ETgvxljAAr70dd3BGGaCXDqN+R3YLNdZ0VtOf9sUMLjJurimYrjwr1pRSSBNDl5YrWb26ITyoWScBeDiMmvvTODj+AEqh7bHggbX5bN8MrCRPH65F/oW1XtQtc06ILkHcJPLFU8l4bS/dp/obRl8jyW", + "created_at": 1791467348, + "id": "4a23764efd400f30cae1704abfba4a7dc16470217d49ea7f3945916eef35a79d", + "kind": 24242, + "pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "sig": "e70f241a08385bc54a807fec1aba2d8b3cbf78b37604dedf46502ec35c69cbb1ede61b144263897ed99ab678c1a9a45f353211d1b43ea20ff7d31ad3d242b34f", + "tags": [ + [ + "p", + "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"d2f2e83674fc1a94792255d966aab54abd76e8eab15f27eca8584d40b60317b3\",\"timestamp\":1791467352}" + } + ], + "index": 4, + "nip44": [ + { + "length": 1, + "nonce": "1c69977ff38e31e388fba8e69046a7b65691c1c5461d23d7733217d758b0897c", + "payload": "Ahxpl3/zjjHjiPuo5pBGp7ZWkcHFRh0j13MyF9dYsIl8+YFEMpmqMesthEM5/w37z8lvCZWQ88dMHc7DqDDgxdhXhEyIXvoaIm3NE6h7ZWa99UdHJRicuJzFMIrsdcBGiPSb" + }, + { + "length": 16, + "nonce": "5564d89263b681bb64b6a5ecb9b798b92c413444a406ed48da5de826663210c3", + "payload": "AlVk2JJjtoG7ZLal7Lm3mLksQTREpAbtSNpd6CZmMhDD++qsJe08B86le7wlsCqqCdg36MQ5EfFwLLh8WqX4iiwAswXy6Sfy9yJ3XJ/HGu6N/d9SPBxAMO5wWlk1uBLyIv7L" + }, + { + "length": 31, + "nonce": "3e0b0ee5b9577179290dcc79dd5abcbf2d6aa6f8b02d5cc5aa5724b48fb9962c", + "payload": "Aj4LDuW5V3F5KQ3Med1avL8taqb4sC1cxapXJLSPuZYs4WLXOHaAHlMOu9UQvRpFAK0KUN51/gv1GUome6mrSByqoeP9/W6Le7FtykdFJxpepqckqPv8CzWvHiACFTUqDBJO" + }, + { + "length": 32, + "nonce": "09d116af03e0a744e2df6cb2680546508d1242eb23de986df97c9c53e7a49e7f", + "payload": "AgnRFq8D4KdE4t9ssmgFRlCNEkLrI96Ybfl8nFPnpJ5/jza/Sw061NDxo0sihV8CgZZDcAJ79kontIiU5+FaBXfRTAFR8R7LeX+feyP6EPtSqOQFfF9tpldUgFGMor1Nd0wZ" + }, + { + "length": 33, + "nonce": "91bf679d486db1a134bc0610bf5832e87773858ab80bbf87a63341321961e56f", + "payload": "ApG/Z51IbbGhNLwGEL9YMuh3c4WKuAu/h6YzQTIZYeVvcfu8dWTTYvlwm7/2w85LMdBGSrDN3qBg/sGMxv/Xxlik6BvLIJavvmxVFKPBvS008OCrqdy598K+dSFX6Lrs3i1exO8/KcvrvfGmEaQ0VVfFrMLqELHrRysmfhe1rSxB5GQ=" + }, + { + "length": 64, + "nonce": "52e3346af81d9e4c18765ae23c11cb017fe02a6e9f51d5dc9f21211ef7731aae", + "payload": "AlLjNGr4HZ5MGHZa4jwRywF/4Cpun1HV3J8hIR73cxqu1AwF6C5xtXbO8VKinCShpl05KhUSklgxb6GGM87vZXwtHxyoLI1PQW3CVMfGqTC4CWyQ02D0VaP6IqK338hIT632eqazN7SXSAUk/WdtMEcLul9SFR6saaBB9v4YQ5iSSKQ=" + }, + { + "length": 65, + "nonce": "4243702f2b82f5a460b2c73737d0452cf3d040097bc4af6a53a7474e0c3cf7e8", + "payload": "AkJDcC8rgvWkYLLHNzfQRSzz0EAJe8SvalOnR04MPPfo5dTqcfnkPSjlNZ+GPG6hVMgp04q9oOwqx98t8+NjFxM97oGb+F8taiY+MgTvEb+z6Jqf3/Q8tGdKyH4L0YixITlUf5EI5vePLkLwnv+WTpemc7VuUfgidxH9dUTWEQTYxtL6EQ0gjI4tEjoXSRbswbXJ9PE31vcI+svysWa8TRV5Sg==" + }, + { + "length": 255, + "nonce": "276eaf1baf6f4b911a4e857d04fe411859a6518d6d5e86011f095426458cde52", + "payload": "Aidurxuvb0uRGk6FfQT+QRhZplGNbV6GAR8JVCZFjN5SEXcmfAX0sP0LP0JTDNw0dNPC7Rt6azC25EG75nFyhbhFKRPh7PQluJMa49nWJLvKEv92AmIc0sucQisAp9Ge7dyya1AY9yOBRaL5BKn4GCuW4pGm38XzKKOlFY1DKE4kg2vtFDGHknSYlAYrVBW6OS4uRXo4aee8Z4mVGwzO6A3DEMFV1HfNImWGK4QHcwwFLhtKO20j2s13bqV4jaAS6S0DdEY5mqMLHKF77j4FBHZeG//Z5Lgzl7QNMOoQ1bwfHvBeat+nZJdT6SxmwKarJSpelo2rcR761X3poX2NS/JBSXiAZqgYDuMB6/7UCdcYIHBJAr+dVT/rBs9K7d4ue3HKQT171USmslyod7d7iA6XC5QCrikZv+WIi5kN0LTUeWI=" + }, + { + "length": 256, + "nonce": "da9ef386af6f248191670a3587581c0dd45fe1708b38ae866873c1bf3be336ab", + "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+di23uEwcKokdLQBvzkgpqNpx9xB7fWEiIgj2lN8BgGk5P5ety1HKT9JlJWU+ppNiXWzTAH/yVjT95ioThZIX1n912RJSPxrYGAmEPGyyjD1YhAVnfZhC4zO1ND72jlSjkSFx1c7UTz9+cCRnzTeTRSJhWsoGVdU7TvgBV0NGIE0VXpHiv2lWsxve4OW9YMlx2wScuzmB66bYWfpkl7sgTQWOKvO+jtUg7lLJcRK7dCESoJVWDrzsIBK3rv+VqjhQz9oEj1TRhZ0eJ1ni6Axxx+uJsVXiq0FFpl1nfKSNaQx/88FkzsLaS0uXdfqDxgm+WXqEkid3YPxC/FNaiVcgl/0WWdiMCvWu3qkhFG+e2xuxs7DgZEOc+rKRBcWxcVM3xXkPQGKwASJOsc8AeLePzIV2PADTBpgqMlR+7UNsbVdL8YrwnFqLbs4Zyxuyy9R+Gj7UiY7xaxpLGlPWGFsWN6zCGtSHlmzUoNBG" + }, + { + "length": 300, + "nonce": "40ff8c18d0f652b4df34d16b6dbdaba5508f6a9b8e50fbd79fc8290249a6361f", + "payload": "AkD/jBjQ9lK03zTRa229q6VQj2qbjlD715/IKQJJpjYflMw1CPFxk5kYVUQRJ7UNEvku3sykO8HmB951UmeHaeEuNLoDxz87X2MSec900uhn3GV7imlS0zIIXidhp46k+BxjtIgyHkKat+HdTnBhb8SSrS3uvTmNbPoPayY/NdNSS3HuHsOULlYdGA+OfcxSVKIS9XLLpIUQUcrHUu1C/jvZu89cyYrw8ydvcrRTxvdUX6OT34wVGnh2FcGYF+snSGPj+zOetHJcvHPd4YmQuPBpmZkDe6Ig4zennCPttEgDh+RlVEvacbTXH86QtQZeprMMJsdVFtjBcH0UXwg3vgM5vLkuGkPr4DpAzgdtfSnX1Ht+iTpfBYn/XrS7mMEr6Po4K87SyyVmRgFyzSIrKxc3e2F+juSVIxE33LkmFOQH8ZVEmGaTOaWbqNtACo+HRhLqmoYu2lalg6IsjBbadiIAwsNYm1HkFTn2o8DtwakZig87tKmKjDX07IHUeKnStTuR" + }, + { + "length": 1000, + "nonce": "0e2344313f168f53586fb4198a97093a4ff43ee06386ffcecda1cfd06c1293b9", + "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": "4e8245c343d0987e57e476e6a5966b718d644df5dffd4b851b124da0809c3f99" + }, + { + "length": 16385, + "nonce": "09262a342ed3e1b304aea5a803ed4d27fb5c383ed31323b218348d759f263809", + "payload_sha256": "164f34f914a478d1ff2a2ff15b5edb06b0beb2f8f321992327eeb04b5eee531b" + }, + { + "length": 65408, + "nonce": "336a3fde9e6354b33ff14db56f59c5357fac6e96374f7656afc1822f3ed786c4", + "payload_sha256": "205fc34e1e0b3f363ae5a8975226ceee3e088eb585fb9a47eb640b62ee96a054" + } + ], + "peer_pubkey": "67fad03bf67761081bfb2f15fa70c4069c1c6ea4b1d557f3f83ff87814180e07", + "peer_secret": "2875faf11d95de0042df207ea55ae62a67664010a3f8b406b1b548028d5d574e", + "proofs": [ + { + "proof": "7bbbe31d6ffc4824a79c8d90a4cff0c43cee04733bf17842516b98837f866d11fa8da08b0638e9ff10b75aef1f6b0a56e2f0a1e7d958e8dc95cecafea447b141", + "timestamp": 0 + }, + { + "proof": "f447a28037f890063cf70e6ad7f7da0a3792c1fdc5c72d5cb0d5e9d8d356c96f21b72bf117813e2a2fb8dabb36414a814529945c8d2cb506b1fc215010febd04", + "timestamp": 1700000000 + }, + { + "proof": "ae0d455a158348eabd5bfa9123d64d7044874ef4784b0498ffeb2b222bfeb6cdafaed598c12d49ebf2273bfdcb661e2f7217ab5383fd48fc7903da76f3642017", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "fb862981a8a770b66e8042132092014236f6bf86d4a1de019446faf8f195da43" + }, + { + "announce": { + "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": "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1", + "sig": "13d566b0e8ce386f49c301b01b31296bc8325a8d19b39e47792bf8a084842d9e268e2b7fe913a63d43ca7e9cecc28c67db04ffac0bd44993cc9b1b383dd9237c", + "tags": [ + [ + "g", + "72f31c7905ff3608414fd9bc6ce86befc7eb9342c4cc400d6fdefbd4f72f8bb6" + ], + [ + "t", + "announce" + ], + [ + "p", + "f962d708a36d1ad3218b071c3298c4191ed17dc42526f47fc405825311656941" + ], + [ + "p", + "637ae677c5fe9f249add838ec5d20e74d6961cc26ef6ef9f7007cb635675ceb1" + ], + [ + "p", + "3dfd0ce7ecc876c78b02678ddc6e8f53284e8deae7b601e61993b33e79f3e342" + ], + [ + "p", + "c0ded7da761bd09c6514c27066725fb7bc4b19ea589c10edd3948e8672f335b1" + ] + ] + }, + "events": [ + { + "event": { + "content": "AmBdKFELkPoqwkzLKVcHTVt0i1rHPWDMBYroqNYu+RVX4VLLcPUUI/+8kG+YudWhxLi+GuPQuor2w+ZHGlwvgg9qMeZtg2+XfQqb5uQcl9hg/5m6EIsIBTmx/uaI6kmoZeXi189VuqZlQIlIROxomxxVCmwjZ6RnWDf933IpHvVwFZJrLLmBCJhSwP4QNGWfRf52cieAvzwrXL/47uTvq1+mXbJj2DQNCe4hV0YN49r0u0oGtwrZy0dwmspIbENWq276", + "created_at": 1791467348, + "id": "85c9c17419152004b9f8fd0cf23b3ae8960662e1bbfc51ad2e25f0896d505f16", + "kind": 24242, + "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "sig": "c1f9475f94cefdd356e9454e9be1c76f1f6f40c241fd3c16d207d3464a484f299ea38e86ab0b705df076eb58154ece0887cdc623a308e18b9d733e8a29b999f4", + "tags": [ + [ + "p", + "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" + ], + [ + "t", + "pong" + ] + ] + }, + "plaintext": "{\"type\":\"pong\",\"challenge\":\"2dd00bd77e0222ced882665481a9c1d9f907309d16e05ed007a1ea63928477a9\",\"timestamp\":1791467352}" + }, + { + "event": { + "content": "Ao9jWX92sTB+QIRu1gm8pYdir99jEgBnnNzfJl9IKZ+JlrYpBJhWA+CeXssIc51tu1H4ZGMy0eeEr6zuiXDu9N7+Z9oDyPFzBODFszWT0mhvJjIlNMCxyF5J9DMLafkT0H6ypBXffb5l4WPjZsMNwFJQy2orvRlHLpWxD1yuxbEnWCuOHaUWCfQymutyBDolttmGEhWrYqc125yuCxy0vTQBK59PpEZg0hLAkSVgxWqnkBJ27uBMu6nu78arEuDAlyql", + "created_at": 1791467349, + "id": "a94c7b867f15406e95d8105d69fc9470267af890e3dcd0d4601139923fdc64e7", + "kind": 24242, + "pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "sig": "65343f0783d8a44857fb6d8c668380547b86ece71d3ac1747d9638b71b013b5481bae2523a869b4fb64f240a2065d86f4ad038b8e06f91301e986354fb250ae3", + "tags": [ + [ + "p", + "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" + ], + [ + "t", + "ping" + ] + ] + }, + "plaintext": "{\"type\":\"ping\",\"challenge\":\"ff7f8e49ae2528f9692b635665ab3cec76b2262fe05c853b677d2fbe8e3fc85f\",\"timestamp\":1791467352}" + } + ], + "index": 5, + "nip44": [ + { + "length": 1, + "nonce": "3c7ac117cc2377f234f529e9cd6ef74fab4743020ef5c03422382f234677a660", + "payload": "Ajx6wRfMI3fyNPUp6c1u90+rR0MCDvXANCI4LyNGd6ZgkOsgDV9hZbao3fwqzM71WmeRNBd0T9lNM8G3a4CwXfu98AfZ6Ljyb+6tQjhAiR+rbVoMfTG6oVWawrOT0ovM/8lH" + }, + { + "length": 16, + "nonce": "ecb19febaae9cc3585efabbef1fa716420cd1f454d0dfa8ab2820fcb7f447860", + "payload": "Auyxn+uq6cw1he+rvvH6cWQgzR9FTQ36irKCD8t/RHhgz0mQRnWeche3+oVIfyKx1JqY9YRDWtjpivbn6uDaeeb9K9UpWTcio7m36mAPsY8ze9HEKITURX/7SbZX4wlXMuA4" + }, + { + "length": 31, + "nonce": "a652aa09714288e2fcc7934abbb7fa2d4dff8c902757696c3962b299bcc2dbb9", + "payload": "AqZSqglxQoji/MeTSru3+i1N/4yQJ1dpbDlispm8wtu5urm3YZOxXsVgOrZjGBhoyPKmGBaknaLB6Ze3t5G4iLOCqh+BbRoczLcpq2TmLIHemty25wwVYSdG41vzziBmLLXP" + }, + { + "length": 32, + "nonce": "9b21df32e4cd885166a4300ea670dcab9246bfae9a21ef1191820d6a41ed3836", + "payload": "Apsh3zLkzYhRZqQwDqZw3KuSRr+umiHvEZGCDWpB7Tg2Yj2QOKvuM8w+NVgJ1Fg75phVBhH/ayCBv2AXJETdN5YnzpDMp+LnrVzcOe4O8Mhd8a1foGWPS/m9h7E2xQ0QBxYP" + }, + { + "length": 33, + "nonce": "f2b8a78b996aaf89aac6ca058e928da7fb9bf74d41230c321cc49e577b036242", + "payload": "AvK4p4uZaq+JqsbKBY6Sjaf7m/dNQSMMMhzEnld7A2JCLkZujn9v59wmK696HfHP26vXvHKkNCQBXDNbXUW/tC79MPXavVCvURjtWSFqSKcqpOdiKgQk9bhteCgoNAVo0WtqH8JgsYuS1p7ssRTfTcJ47WJbWG32FCCJs/01XrczoPw=" + }, + { + "length": 64, + "nonce": "67f6b822b700f7a8de753c33fec9a9d5f5fc726591909464ad200a87ea3ef9fa", + "payload": "Amf2uCK3APeo3nU8M/7JqdX1/HJlkZCUZK0gCofqPvn6zA3hLLC2QpYM5XNnrPsYSPB1aH2Y3al3XTWdOWV1queUlFKC0VkbkopZJMYux4SVGN24Hx+SUYQAeLMZLsEiiCf0pFukPE9YraLf5sz9ixlCWCOE4B84knimaJGzb/L0KTI=" + }, + { + "length": 65, + "nonce": "2ea8e9e38e9ff0dfc3e8f0ec568071d6fc78202ee9df257cbb3920f2e2f4e01c", + "payload": "Ai6o6eOOn/Dfw+jw7FaAcdb8eCAu6d8lfLs5IPLi9OAc8aKoda563rG34fTchHM7hzDUwkVHcjyvpQtjoW8aQRcDiF2dVXYWsGnn7oHgEDiqr+JVCUZb81nk6sWE5+KW6E2ZqC6Pb8Y+4yPmcIjCTR+OZlcaFCqVF+pPAux4oQIg4bvIapDWLNbpIavC/+88UM8a21y8ULKzDL4GfrfY/CfKDg==" + }, + { + "length": 255, + "nonce": "b36b8dc28587782b60f0ee4be993a630461f20ea9c516ddc45f1e68af9c8fd27", + "payload": "ArNrjcKFh3grYPDuS+mTpjBGHyDqnFFt3EXx5or5yP0nDOZL2SWIJEDbxvtsAA8Rc92U1EnGo1l9LV8qTsbQCAdZ1DATG50/j/N+AEzpCQ09Sz84Tgxi0Lo5M9zENEcUifgh1NEi6zAvy7XyTM4kucBgTHQgAvOVVSZ7YaECPJTw3lDJGdVGYKndQKb9JvaVy2REjxSSVu8eLeicvdXljTSi/fFl1RnyKqGdvDIeufgTbUKn5wxHri7o5POBZcJ3j4Tamf1UKpvHdLAlYjjtINtYlOAq2YxRO+5HsJ10Z43LkPZ0sid5h54EClFLQQZF8VYw+EwNp7Yk1h39Mo8ip+pDA067I3ZeSgg5xuryVoDTaMVC7txNGYpVIlJiRgiGcUSV+zi7clgL72W60ycQrU57zfAoNu5e47n9ABlYJSAijL4=" + }, + { + "length": 256, + "nonce": "ae7b1f7757691ca191ab671262cda742cba38011c041584b99d8b460e4006e8a", + "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/BybEo7lEJgVBH5slfDYBNPYL8MbNUCXMpnh7AXBG5y75Pe4wGz4aUg7eJqTNRtuoEabtLDPzOGbQfbLcs4Z7JlM1p7GBOyHicL278lTqrep5bAj8WB++MegODRr2eaJecdhBY5ThSF7/VNve9KZM74rmMMU3PdECNsOm3GH2bm3228B1d43elvYRYDzr+IHDouNfpId3hhrgC0EoKF6gCozU9Qs0LEKWgUTQPCtNRdQTplmjNbUnfMfa0AwHupO8Y53KlkF+ssY5c6LDtzfE5LMJ1Gn5p9QxHhwNYJ+d2bnVH03mCBjjFHVM+FaiNC2pcKJ5JCRjTNooDs5xtXz7DTxzlC/p2a0uXHJJvmJVE8PNUBqJNqVOsMQV8Z/n0K1W99eBmhYuhussi7/uHh1GjJmP7VOuDa0lnXaOajAC1fF34RnMQE0mdpxVdJx9jA+OkigvcUyh+qo/sUyCcKNOUIn8" + }, + { + "length": 300, + "nonce": "089ddffec7be570b01f5b9b2810f6eda4234454a9b5298602389f5ab0de19289", + "payload": "Agid3/7HvlcLAfW5soEPbtpCNEVKm1KYYCOJ9asN4ZKJ2laj37G4Gg3hiBtyhG+c4BxKE0/XKHDbTj3aNz6mh6N+mKVXm7o5wjne2KB7O9lcaQ4+Al51mpcCc/KmDhfAWtY93CjhSBRKBRGhkBTxYh5vj4WoGI11n5c0uvvBUA0g/6zlhZqoqCkXHkJ80asU54VhlFvJVM4DE7PFd9bna15nfvkc+CG3TTADe7plO2lXgR9tp3l5fcxYGWi2fE4POvYbTPeqGQfB8QzjvN6nxylkvssh7Fi2p4fTbeMs8zoTVNcZ3ZkxWLlIkUNUCK9J89m8nUpfIglRa9HKMq/+Vp+VoTKL49OZk0qBS1nbWbGyXE7hGxuHT/MEv/JexTyRfDAfGU04Esin5ZNOiYTnHjlPYq7zPoDYGRt7zH9Pk357DqtpOR42pBn+RGX/yeNpxnbfYmLTDEmJC2HBtd0NTN+3UWoFZ31K2AIogHARjsCZXwpJFuq6RaxmKAtEK5Bvx8nL" + }, + { + "length": 1000, + "nonce": "05628e5d74f4c5083b6e96aa9c29ce88fe3fd8f6efb4539454099c4e9a90b5ea", + "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": "046d0589edfde9a8a8b7503c17983f9ed927f86ab86f2531c638b6d981675caa" + }, + { + "length": 16385, + "nonce": "a76a39705cf4744e4d07ff4bd8bb622bc1b9db21552d3416c47118ef1c74d2c0", + "payload_sha256": "03dc8d7692fabbe0de4e6035ee18e753c6b37cf81b08439235289e76b4db359b" + }, + { + "length": 65408, + "nonce": "914a30009dc97047128a85142f1c56b96bc476b37d163f2ac11e1f7769a6684f", + "payload_sha256": "c9d5e1711f4531602ea90aea12b402ca600b085eeca17418c295bfb34105d7d8" + } + ], + "peer_pubkey": "35eeb290f71a4813621c4487a8d5efc520bebbd909d557cae7560f562b6378df", + "peer_secret": "e0ba0a9c6583de51b416b8cfa5ecfb0810918f28bfdc3d1834f9c3862097c0e8", + "proofs": [ + { + "proof": "457a841726df7babfff2e9d1922aa81ceda096dc8cc47cdbe474091fa1243a55b46cd995c0450ef8edd39d160f967180639d0309a4108da9b85c4e5cf79a24cb", + "timestamp": 0 + }, + { + "proof": "f585b6cf4ff312de2ad0547b2668c6427eb06100e0d525e5726d452e08b0aa4fb6cd548544ab942324e87c332233ad5f21c9d0e3bcb1ac8fcc08eed6f020bc64", + "timestamp": 1700000000 + }, + { + "proof": "963cbd36a1a98e0f0fd4d43733855b22b2fa568f7ce9708c773429a6ebc5476df36b1c6571b6091927350748b4d7b730f7a5dfde5eb123fded1a7788cdeaa3be", + "timestamp": 18446744073709551615 + } + ], + "transport_pubkey": "7cdbfd336f0396d746386d91cdf036ba7731933cde4dff065e648358e510bbc1" + } + ], + "min_signers": 3 + } + ], + "serializations": [ + { + "id": "fa7698ec16b6e398d20a46a34242995866eccc9a2f9a24eaf58b42a8112fbe1e", + "serialized": "[0,\"60baa319e11f8ce8f5ace139204e18e19a1f5b9e348ee49f91ce585c99bd35a1\",1791467348,24242,[[\"p\",\"0a92c456675fbfc3b0ecf764f94ff458a8b6fac9e10c71578fca72f5155e3976\"],[\"t\",\"pong\"]],\"AnBBdUe91DHwrJs8hdaN9GOocyRiETBmmax0QZ2Au5ZbDnMTVSMfJWsoX/0TKyBWVQRiIobn0VxSWktSJ6IDwhfkNquyoEvAPdBAk8OyD9DOgbs4avJUq5f3XEX3E7OIaK37xqWn357U3dYXHp8VJBV8jOlQ252CX+/wEhom0PwHA85KBk5khBxMkO8ioY8KPlTzUsFYfdFVLjEsFk6tFQP3MvNCHBswnMug/V9AYngx33cRTJJXYhrOZfGBeA6po659\"]" + }, + { + "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": [ + { + "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 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/test/vectors/gen-kfp/Cargo.toml b/test/vectors/gen-kfp/Cargo.toml new file mode 100644 index 0000000..11eaaf6 --- /dev/null +++ b/test/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/test/vectors/gen-kfp/src/main.rs b/test/vectors/gen-kfp/src/main.rs new file mode 100644 index 0000000..aca98db --- /dev/null +++ b/test/vectors/gen-kfp/src/main.rs @@ -0,0 +1,207 @@ +// 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. +//! 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: +//! +//! 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}; +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 (test/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]]) +}