Add events on API method calls

contract/src/burn/api.rs

@@ -1,4 +1,8 @@
-use model::{api::BurnApi, TokensAmount, UnixTimestamp};
+use model::{
+    api::BurnApi,
+    event::{emit, BurnData, EventKind},
+    TokensAmount, UnixTimestamp,
+};
 use near_sdk::{json_types::U128, near_bindgen, require, PromiseOrValue};
 
 use crate::{common::now_seconds, Contract, ContractExt};
@@ -50,6 +54,10 @@ impl Contract {
             self.accruals.remove(&datetime);
         }
 
+        emit(EventKind::Burn(BurnData {
+            burnt_amount: U128(total_to_burn),
+        }));
+
         U128(total_to_burn)
     }
 }

contract/src/claim/api.rs

@@ -1,4 +1,8 @@
-use model::{api::ClaimApi, ClaimAvailabilityView, TokensAmount, UnixTimestamp};
+use model::{
+    api::ClaimApi,
+    event::{emit, ClaimData, EventKind},
+    ClaimAvailabilityView, TokensAmount, UnixTimestamp,
+};
 use near_sdk::{env, json_types::U128, near_bindgen, require, store::Vector, AccountId, PromiseOrValue};
 
 use crate::{common::now_seconds, Contract, ContractExt, StorageKey::AccrualsEntry};
@@ -103,6 +107,16 @@ impl Contract {
 
         if is_success {
             account.last_claim_at = now.into();
+
+            let event_data = ClaimData {
+                details: details
+                    .iter()
+                    .map(|(timestamp, amount)| (*timestamp, U128(*amount)))
+                    .collect(),
+                total_claimed: U128(total_accrual),
+            };
+            emit(EventKind::Claim(event_data));
+
             return U128(total_accrual);
         }
 

contract/src/clean/api.rs

@@ -1,3 +1,4 @@
+use model::event::{emit, CleanData, EventKind};
 use near_sdk::{near_bindgen, AccountId};
 
 use crate::{Contract, ContractExt};
@@ -11,8 +12,10 @@ impl CleanApi for Contract {
     fn clean(&mut self, account_ids: Vec<AccountId>) {
         self.assert_oracle();
 
-        for account_id in account_ids {
+        for account_id in account_ids.clone() {
             self.accounts.set(account_id, None);
         }
+
+        emit(EventKind::Clean(CleanData { account_ids }));
     }
 }

contract/src/record/api.rs

@@ -1,4 +1,8 @@
-use model::{account_record::AccountRecord, api::RecordApi};
+use model::{
+    account_record::AccountRecord,
+    api::RecordApi,
+    event::{emit, EventKind, RecordData},
+};
 use near_sdk::{json_types::U128, near_bindgen, require, store::Vector, AccountId};
 
 use crate::{common::now_seconds, Contract, ContractExt, StorageKey::AccrualsEntry};
@@ -8,13 +12,18 @@ impl RecordApi for Contract {
     fn record_batch_for_hold(&mut self, amounts: Vec<(AccountId, U128)>) {
         self.assert_oracle();
 
-        self.assert_oracle();
-
         let now_seconds = now_seconds();
         let mut balances = Vector::new(AccrualsEntry(now_seconds));
         let mut total_balance = 0;
 
+        let mut event_data = RecordData {
+            timestamp: now_seconds,
+            amounts: vec![],
+        };
+
         for (account_id, amount) in amounts {
+            event_data.amounts.push((account_id.clone(), amount));
+
             let amount = amount.0;
             let index = balances.len();
 
@@ -36,6 +45,8 @@ impl RecordApi for Contract {
 
         let existing = self.accruals.insert(now_seconds, (balances, total_balance));
 
+        emit(EventKind::Record(event_data));
+
         require!(
             existing.is_none(),
             format!("Record for this timestamp: {now_seconds} already existed. It was owerwritten.")

model/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "model"
-version = "0.1.0"
+version = "1.0.0"
 edition = "2021"
 
 [lib]

model/src/event.rs

@@ -0,0 +1,129 @@
+use near_sdk::{
+    env,
+    json_types::U128,
+    log,
+    serde::{Deserialize, Serialize},
+    serde_json, AccountId,
+};
+
+use crate::UnixTimestamp;
+
+pub const PACKAGE_NAME: &str = "sweat_claim";
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(
+    crate = "near_sdk::serde",
+    tag = "event",
+    content = "data",
+    rename_all = "snake_case"
+)]
+pub enum EventKind {
+    Burn(BurnData),
+    Claim(ClaimData),
+    Clean(CleanData),
+    Record(RecordData),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde")]
+pub struct BurnData {
+    pub burnt_amount: U128,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde")]
+pub struct ClaimData {
+    pub details: Vec<(UnixTimestamp, U128)>,
+    pub total_claimed: U128,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde")]
+pub struct CleanData {
+    pub account_ids: Vec<AccountId>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde")]
+pub struct RecordData {
+    pub timestamp: UnixTimestamp,
+    pub amounts: Vec<(AccountId, U128)>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(crate = "near_sdk::serde", rename_all = "snake_case")]
+struct SweatClaimEvent {
+    standard: &'static str,
+    version: &'static str,
+    #[serde(flatten)]
+    event_kind: EventKind,
+}
+
+impl From<EventKind> for SweatClaimEvent {
+    fn from(event_kind: EventKind) -> Self {
+        Self {
+            standard: PACKAGE_NAME,
+            version: VERSION,
+            event_kind,
+        }
+    }
+}
+
+pub fn emit(event: EventKind) {
+    log!(SweatClaimEvent::from(event).to_json_event_string());
+}
+
+impl SweatClaimEvent {
+    fn to_json_string(&self) -> String {
+        serde_json::to_string_pretty(self)
+            .unwrap_or_else(|err| env::panic_str(&format!("Failed to serialize SweatClaimEvent: {err}")))
+    }
+
+    fn to_json_event_string(&self) -> String {
+        format!("EVENT_JSON:{}", self.to_json_string())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use near_sdk::json_types::U128;
+
+    use crate::event::{BurnData, EventKind, SweatClaimEvent};
+
+    #[test]
+    fn event_to_string() {
+        assert_eq!(
+            strip(
+                SweatClaimEvent::from(EventKind::Burn(BurnData {
+                    burnt_amount: U128(100_000_000),
+                }))
+                .to_json_event_string()
+                .as_str()
+            ),
+            strip(
+                r#"EVENT_JSON:{
+                "standard": "sweat_claim",
+                "version": "1.0.0",
+                "event": "burn",
+                "data": {
+                  "burnt_amount": "100000000"
+                }}"#
+            )
+        )
+    }
+
+    fn strip(s: &str) -> String {
+        let without_newlines: String = s.chars().filter(|&c| c != '\n').collect();
+        let mut previous_char = ' ';
+        let result: String = without_newlines
+            .chars()
+            .filter(|&c| {
+                let keep = !(c == ' ' && previous_char == ' ');
+                previous_char = c;
+                keep
+            })
+            .collect();
+        result
+    }
+}

model/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod account_record;
 pub mod api;
+pub mod event;
 
 use near_sdk::serde::{Deserialize, Serialize};