Vara.ETH Testnet
— Mission Complete

#![no_std]

use sails_rs::{cell::RefCell, prelude::*};

// Model of the service's data. Only service knows what is the data
// and how to manipulate it.
pub struct CounterData {
    counter: u32,
}

impl CounterData {
    // The only method exposed publicly for creating a new instance of the data.
    pub const fn new(counter: u32) -> Self {
        Self { counter }
    }
}

// Service event type definition.
#[event]
#[sails_type]
#[derive(Clone, Debug, PartialEq)]
pub enum CounterEvents {
    /// Emitted when a new value is added to the counter
    Added(u32),
    /// Emitted when a value is subtracted from the counter
    Subtracted(u32),
}

// `CounterService` is generic over its state handle `S: StateMut`. The impl
// stays agnostic of how the data is stored — any type that implements
// `StateMut<Item = CounterData, Error = Infallible>` works:
// a `&RefCell<CounterData>` borrowed from program state (production default),
// an owned `RefCell<CounterData>`, an `Rc<RefCell<CounterData>>`, a
// `&mut RefCell<CounterData>` (via the `&mut S` blanket in `state.rs`), or a
// custom wrapper (pausing, metering, etc.).
pub struct CounterService<
    S: StateMut<Item = CounterData, Error = Infallible> = RefCell<CounterData>,
> {
    data: S,
}

impl<S: StateMut<Item = CounterData, Error = Infallible>> CounterService<S> {
    // Service constructor demands the state handle to be passed from outside.
    pub fn new(data: S) -> Self {
        Self { data }
    }
}

// Declare the service can emit events of type CounterEvents.
#[service(events = CounterEvents)]
impl<S: StateMut<Item = CounterData, Error = Infallible>> CounterService<S> {
    /// Add a value to the counter
    #[export]
    pub fn add(&mut self, value: u32) -> u32 {
        let counter = {
            // Access mutable state
            let mut data_mut = self.data.get_mut();
            data_mut.counter += value;
            data_mut.counter
        };

        // Emit event right before the method returns via
        // the generated `emit_event` method.
        self.emit_event(CounterEvents::Added(value)).unwrap();
        counter
    }

    /// Subtract a value from the counter
    #[export]
    pub fn sub(&mut self, value: u32) -> u32 {
        let counter = {
            // Access mutable state
            let mut data_mut = self.data.get_mut();
            data_mut.counter -= value;
            data_mut.counter
        };
        // Emit event right before the method returns via
        // the generated `emit_event` method.
        self.emit_event(CounterEvents::Subtracted(value)).unwrap();
        counter
    }

    /// Get the current value
    #[export]
    pub fn value(&self) -> u32 {
        self.data.get().counter
    }
}

pub struct Program {
    counter_data: RefCell<CounterData>,
}

#[program]
impl Program {
    // Program's constructor
    pub fn init(counter: u32) -> Self {
        Self {
            counter_data: RefCell::new(CounterData::new(counter)),
        }
    }

    // Exposed service
    pub fn counter(&self) -> CounterService<&RefCell<CounterData>> {
        CounterService::new(&self.counter_data)
    }
}

use counter_client::{CounterClient, CounterClientCtors, counter::*};
use sails_rs::{client::*, gtest::ethexe::*};

const ACTOR_ID: u64 = 42;

#[tokio::test]
async fn do_something_works() {
    let system = System::new();
    system.init_logger_with_default_filter(
        "gwasm=debug,gtest=info,sails_rs=debug"
    );
    system.mint_to(ACTOR_ID, 100_000_000_000_000);
    // Submit program code into the system
    let program_code_id = system.submit_code(counter::WASM_BINARY);

    // Create Sails Env
    let env = GtestEnv::new(system, ACTOR_ID.into());

    let program = env
        .deploy::<counter_client::CounterClientProgram>(
            program_code_id, b"salt".to_vec()
        )
        .init(5) // Call program's constructor
        .await
        .unwrap();

    let mut counter_service_client = program.counter();

    assert_eq!(counter_service_client.value().await.unwrap(), 5);

    assert_eq!(counter_service_client.add(37).await.unwrap(), 42);
    assert_eq!(counter_service_client.value().await.unwrap(), 42);
}