Remove ability to remove events

rs/canister/api/can.did

@@ -2,7 +2,6 @@ type EventsArgs = record { start : nat64; length : nat64 };
 type EventsResponse = record {
   events : vec IndexedEvent;
   latest_event_index : opt nat64;
-  earliest_event_index_stored : opt nat64;
 };
 type IdempotentEvent = record {
   source : opt text;
@@ -21,24 +20,16 @@ type IndexedEvent = record {
   payload : vec nat8;
 };
 type InitArgs = record {
-  remove_events_whitelist : vec principal;
   push_events_whitelist : vec principal;
   read_events_whitelist : vec principal;
 };
 type PushEventsArgs = record { events : vec IdempotentEvent };
-type RemoveEventsArgs = record { up_to_inclusive : nat64 };
-type RemoveEventsResponse = record {
-  latest_event_index : opt nat64;
-  earliest_event_index_stored : opt nat64;
-};
 type WhitelistedPrincipals = record {
-  remove : vec principal;
   push : vec principal;
   read : vec principal;
 };
 service : (InitArgs) -> {
   events : (EventsArgs) -> (EventsResponse) query;
   push_events : (PushEventsArgs) -> ();
-  remove_events : (RemoveEventsArgs) -> (RemoveEventsResponse);
   whitelisted_principals : () -> (WhitelistedPrincipals) query;
 }

rs/canister/api/src/lifecycle/init.rs

@@ -5,5 +5,4 @@ use serde::Serialize;
 pub struct InitArgs {
     pub push_events_whitelist: Vec<Principal>,
     pub read_events_whitelist: Vec<Principal>,
-    pub remove_events_whitelist: Vec<Principal>,
 }

rs/canister/api/src/queries/events.rs

@@ -12,5 +12,4 @@ pub struct EventsArgs {
 pub struct EventsResponse {
     pub events: Vec<IndexedEvent>,
     pub latest_event_index: Option<u64>,
-    pub earliest_event_index_stored: Option<u64>,
 }

rs/canister/api/src/queries/whitelisted_principals.rs

@@ -5,5 +5,4 @@ use serde::Serialize;
 pub struct WhitelistedPrincipals {
     pub read: Vec<Principal>,
     pub push: Vec<Principal>,
-    pub remove: Vec<Principal>,
 }

rs/canister/api/src/updates/mod.rs

@@ -1,5 +1,3 @@
 mod push_events;
-mod remove_events;
 
 pub use push_events::*;
-pub use remove_events::*;

rs/canister/impl/src/guards.rs

@@ -16,14 +16,6 @@ pub fn caller_can_read_events() -> Result<(), String> {
     }
 }
 
-pub fn caller_can_remove_events() -> Result<(), String> {
-    if state::read(|s| s.can_caller_remove_events()) {
-        Ok(())
-    } else {
-        Err(err_message("remove"))
-    }
-}
-
 fn err_message(action: &'static str) -> String {
     format!("Caller is not authorized to {action} events")
 }

rs/canister/impl/src/lifecycle/init.rs

@@ -8,6 +8,5 @@ fn init(args: InitArgs) {
     state::init(State::new(
         args.push_events_whitelist.into_iter().collect(),
         args.read_events_whitelist.into_iter().collect(),
-        args.remove_events_whitelist.into_iter().collect(),
     ));
 }

rs/canister/impl/src/model/events.rs

@@ -11,12 +11,8 @@ pub struct Events {
 
 impl Events {
     pub fn get(&self, start: u64, length: u64) -> Vec<IndexedEvent> {
-        if let Some(start_index) = self
-            .earliest_event_index_stored()
-            .and_then(|i| start.checked_sub(i))
-            .map(|i| i as usize)
-            .filter(|i| *i < self.events.len())
-        {
+        let start_index = start as usize;
+        if start_index < self.events.len() {
             self.events
                 .range(start_index..)
                 .take(length as usize)
@@ -40,30 +36,13 @@ impl Events {
         self.latest_event_index = Some(index);
     }
 
-    pub fn remove(&mut self, up_to_inclusive: u64) {
-        while self
-            .events
-            .front()
-            .filter(|e| e.index <= up_to_inclusive)
-            .is_some()
-        {
-            self.events.pop_front();
-        }
-    }
-
     pub fn stats(&self) -> EventsStats {
         EventsStats {
-            earliest_event_index_stored: self.earliest_event_index_stored(),
             latest_event_index: self.latest_event_index,
         }
     }
-
-    fn earliest_event_index_stored(&self) -> Option<u64> {
-        self.events.front().map(|e| e.index)
-    }
 }
 
 pub struct EventsStats {
-    pub earliest_event_index_stored: Option<u64>,
     pub latest_event_index: Option<u64>,
 }

rs/canister/impl/src/queries/events.rs

@@ -12,7 +12,6 @@ fn events(args: EventsArgs) -> EventsResponse {
         EventsResponse {
             events,
             latest_event_index: stats.latest_event_index,
-            earliest_event_index_stored: stats.earliest_event_index_stored,
         }
     })
 }

rs/canister/impl/src/state.rs

@@ -15,7 +15,6 @@ thread_local! {
 pub struct State {
     push_events_whitelist: HashSet<Principal>,
     read_events_whitelist: HashSet<Principal>,
-    remove_events_whitelist: HashSet<Principal>,
     pub events: Events,
     pub event_deduper: EventDeduper,
 }
@@ -49,12 +48,10 @@ impl State {
     pub fn new(
         push_events_whitelist: HashSet<Principal>,
         read_events_whitelist: HashSet<Principal>,
-        remove_events_whitelist: HashSet<Principal>,
     ) -> State {
         State {
             push_events_whitelist,
             read_events_whitelist,
-            remove_events_whitelist,
             events: Events::default(),
             event_deduper: EventDeduper::default(),
         }
@@ -70,16 +67,10 @@ impl State {
         self.read_events_whitelist.contains(&caller)
     }
 
-    pub fn can_caller_remove_events(&self) -> bool {
-        let caller = env::caller();
-        self.remove_events_whitelist.contains(&caller)
-    }
-
     pub fn whitelisted_principals(&self) -> WhitelistedPrincipals {
         WhitelistedPrincipals {
             push: self.push_events_whitelist.iter().copied().collect(),
             read: self.read_events_whitelist.iter().copied().collect(),
-            remove: self.remove_events_whitelist.iter().copied().collect(),
         }
     }
 }

rs/canister/impl/src/updates/mod.rs

@@ -1,2 +1 @@
 mod push_events;
-mod remove_events;

rs/integration_tests/src/client.rs

@@ -1,7 +1,5 @@
 use candid::{CandidType, Principal};
-use event_sink_canister::{
-    EventsArgs, EventsResponse, PushEventsArgs, RemoveEventsArgs, RemoveEventsResponse,
-};
+use event_sink_canister::{EventsArgs, EventsResponse, PushEventsArgs};
 use pocket_ic::{PocketIc, UserError, WasmResult};
 use serde::de::DeserializeOwned;
 
@@ -23,15 +21,6 @@ pub fn push_events(
     execute_update_no_response(env, sender, canister_id, "push_events", args)
 }
 
-pub fn remove_events(
-    env: &mut PocketIc,
-    sender: Principal,
-    canister_id: Principal,
-    args: &RemoveEventsArgs,
-) -> RemoveEventsResponse {
-    execute_update(env, sender, canister_id, "remove_events", args)
-}
-
 fn execute_query<P: CandidType, R: CandidType + DeserializeOwned>(
     env: &PocketIc,
     sender: Principal,
@@ -47,6 +36,7 @@ fn execute_query<P: CandidType, R: CandidType + DeserializeOwned>(
     ))
 }
 
+#[allow(dead_code)]
 fn execute_update<P: CandidType, R: CandidType + DeserializeOwned>(
     env: &mut PocketIc,
     sender: Principal,

rs/integration_tests/src/lib.rs

@@ -2,9 +2,7 @@
 use crate::rng::{random, random_bytes, random_principal, random_string};
 use crate::setup::setup_new_env;
 use candid::Principal;
-use event_sink_canister::{
-    EventsArgs, IdempotentEvent, InitArgs, PushEventsArgs, RemoveEventsArgs,
-};
+use event_sink_canister::{EventsArgs, IdempotentEvent, InitArgs, PushEventsArgs};
 use pocket_ic::PocketIc;
 use std::fs::File;
 use std::io::Read;
@@ -20,17 +18,15 @@ pub struct TestEnv {
     pub controller: Principal,
     pub push_principals: Vec<Principal>,
     pub read_principals: Vec<Principal>,
-    pub remove_principals: Vec<Principal>,
 }
 
 #[test]
-fn read_push_remove_events_succeeds() {
+fn push_then_read_events_succeeds() {
     let TestEnv {
         mut env,
         canister_id,
         push_principals,
         read_principals,
-        remove_principals,
         ..
     } = install_canister(None);
 
@@ -66,17 +62,6 @@ fn read_push_remove_events_succeeds() {
     assert_eq!(read_response.events.first().unwrap().index, 0);
     assert_eq!(read_response.events.last().unwrap().index, 4);
     assert_eq!(read_response.latest_event_index, Some(9));
-    assert_eq!(read_response.earliest_event_index_stored, Some(0));
-
-    let remove_response = client::remove_events(
-        &mut env,
-        *remove_principals.first().unwrap(),
-        canister_id,
-        &RemoveEventsArgs { up_to_inclusive: 5 },
-    );
-
-    assert_eq!(remove_response.latest_event_index, Some(9));
-    assert_eq!(remove_response.earliest_event_index_stored, Some(6));
 }
 
 fn install_canister(init_args: Option<InitArgs>) -> TestEnv {
@@ -86,7 +71,6 @@ fn install_canister(init_args: Option<InitArgs>) -> TestEnv {
     let init_args = init_args.unwrap_or_else(|| InitArgs {
         push_events_whitelist: vec![random_principal()],
         read_events_whitelist: vec![random_principal()],
-        remove_events_whitelist: vec![random_principal()],
     });
 
     let canister_id = env.create_canister_with_settings(Some(controller), None);
@@ -104,7 +88,6 @@ fn install_canister(init_args: Option<InitArgs>) -> TestEnv {
         controller,
         push_principals: init_args.push_events_whitelist,
         read_principals: init_args.read_events_whitelist,
-        remove_principals: init_args.remove_events_whitelist,
     }
 }
 

ts/consumer/src/candid/idl.d.ts

@@ -2,7 +2,6 @@ import type { IDL } from "@dfinity/candid";
 export type {
   IndexedEvent as CandidEvent,
   EventsResponse as CandidEventsResponse,
-  RemoveEventsResponse as CandidRemoveEventsResponse,
   _SERVICE as EventSinkCanister,
 } from "./types";
 

ts/consumer/src/candid/idl.js

@@ -1,6 +1,5 @@
 export const idlFactory = ({ IDL }) => {
   const InitArgs = IDL.Record({
-    'remove_events_whitelist' : IDL.Vec(IDL.Principal),
     'push_events_whitelist' : IDL.Vec(IDL.Principal),
     'read_events_whitelist' : IDL.Vec(IDL.Principal),
   });
@@ -16,7 +15,6 @@ export const idlFactory = ({ IDL }) => {
   const EventsResponse = IDL.Record({
     'events' : IDL.Vec(IndexedEvent),
     'latest_event_index' : IDL.Opt(IDL.Nat64),
-    'earliest_event_index_stored' : IDL.Opt(IDL.Nat64),
   });
   const IdempotentEvent = IDL.Record({
     'source' : IDL.Opt(IDL.Text),
@@ -27,20 +25,18 @@ export const idlFactory = ({ IDL }) => {
     'idempotency_key' : IDL.Nat,
   });
   const PushEventsArgs = IDL.Record({ 'events' : IDL.Vec(IdempotentEvent) });
-  const RemoveEventsArgs = IDL.Record({ 'up_to_inclusive' : IDL.Nat64 });
-  const RemoveEventsResponse = IDL.Record({
-    'latest_event_index' : IDL.Opt(IDL.Nat64),
-    'earliest_event_index_stored' : IDL.Opt(IDL.Nat64),
+  const WhitelistedPrincipals = IDL.Record({
+    'push' : IDL.Vec(IDL.Principal),
+    'read' : IDL.Vec(IDL.Principal),
   });
   return IDL.Service({
     'events' : IDL.Func([EventsArgs], [EventsResponse], ['query']),
     'push_events' : IDL.Func([PushEventsArgs], [], []),
-    'remove_events' : IDL.Func([RemoveEventsArgs], [RemoveEventsResponse], []),
+    'whitelisted_principals' : IDL.Func([], [WhitelistedPrincipals], ['query']),
   });
 };
 export const init = ({ IDL }) => {
   const InitArgs = IDL.Record({
-    'remove_events_whitelist' : IDL.Vec(IDL.Principal),
     'push_events_whitelist' : IDL.Vec(IDL.Principal),
     'read_events_whitelist' : IDL.Vec(IDL.Principal),
   });

ts/consumer/src/candid/types.d.ts

@@ -5,7 +5,6 @@ export interface EventsArgs { 'start' : bigint, 'length' : bigint }
 export interface EventsResponse {
   'events' : Array<IndexedEvent>,
   'latest_event_index' : [] | [bigint],
-  'earliest_event_index_stored' : [] | [bigint],
 }
 export interface IdempotentEvent {
   'source' : [] | [string],
@@ -24,18 +23,16 @@ export interface IndexedEvent {
   'payload' : Uint8Array | number[],
 }
 export interface InitArgs {
-  'remove_events_whitelist' : Array<Principal>,
   'push_events_whitelist' : Array<Principal>,
   'read_events_whitelist' : Array<Principal>,
 }
 export interface PushEventsArgs { 'events' : Array<IdempotentEvent> }
-export interface RemoveEventsArgs { 'up_to_inclusive' : bigint }
-export interface RemoveEventsResponse {
-  'latest_event_index' : [] | [bigint],
-  'earliest_event_index_stored' : [] | [bigint],
+export interface WhitelistedPrincipals {
+  'push' : Array<Principal>,
+  'read' : Array<Principal>,
 }
 export interface _SERVICE {
   'events' : ActorMethod<[EventsArgs], EventsResponse>,
   'push_events' : ActorMethod<[PushEventsArgs], undefined>,
-  'remove_events' : ActorMethod<[RemoveEventsArgs], RemoveEventsResponse>,
+  'whitelisted_principals' : ActorMethod<[], WhitelistedPrincipals>,
 }