templar_common/oracle/redstone/
event.rs

1use near_sdk::{
2    near,
3    serde::{
4        ser::{SerializeSeq, SerializeStruct},
5        Serialize, Serializer,
6    },
7    AccountId,
8};
9
10use super::{config::SignerAddressBs, feed_data::FeedData, Config, FeedId};
11
12#[near(event_json(standard = "redstone-adapter"))]
13pub enum RedStoneEvent<'a> {
14    #[event_version("1.0.0")]
15    WritePrices {
16        updater: AccountId,
17        updated_feeds: Vec<(FeedId, FeedData)>,
18    },
19
20    /// The effective policy after a successful configuration replacement. Signers are
21    /// lowercase hex strings in this event only, bounding even 255 signers below
22    /// NEAR's 16 KiB receipt-log limit without copying the stored configuration.
23    #[event_version("1.0.0")]
24    ConfigUpdated {
25        updater: AccountId,
26        #[serde(serialize_with = "serialize_config")]
27        config: &'a Config,
28    },
29}
30
31fn serialize_config<S: Serializer>(config: &Config, serializer: S) -> Result<S::Ok, S::Error> {
32    // Keep exhaustive so new config fields require an event-schema decision.
33    let Config {
34        signer_count_threshold,
35        signers,
36        max_timestamp_delay_ms,
37        max_timestamp_ahead_ms,
38        min_interval_between_updates_ms,
39    } = config;
40    let mut data = serializer.serialize_struct("Config", 5)?;
41    data.serialize_field("signer_count_threshold", signer_count_threshold)?;
42    data.serialize_field("signers", &HexSigners(signers))?;
43    data.serialize_field("max_timestamp_delay_ms", max_timestamp_delay_ms)?;
44    data.serialize_field("max_timestamp_ahead_ms", max_timestamp_ahead_ms)?;
45    data.serialize_field(
46        "min_interval_between_updates_ms",
47        min_interval_between_updates_ms,
48    )?;
49    data.end()
50}
51
52struct HexSigners<'a>(&'a [SignerAddressBs]);
53
54impl Serialize for HexSigners<'_> {
55    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
56        let mut signers = serializer.serialize_seq(Some(self.0.len()))?;
57        for signer in self.0 {
58            signers.serialize_element(&HexSigner(signer))?;
59        }
60        signers.end()
61    }
62}
63
64struct HexSigner<'a>(&'a SignerAddressBs);
65
66impl Serialize for HexSigner<'_> {
67    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
68        let mut encoded = [0; 40];
69        hex::encode_to_slice(self.0, &mut encoded).map_err(near_sdk::serde::ser::Error::custom)?;
70        let address = std::str::from_utf8(&encoded).map_err(near_sdk::serde::ser::Error::custom)?;
71        serializer.serialize_str(address)
72    }
73}