Vara.ETH Testnet
on Ethereum Hoodi - Now Live

#![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]
#[derive(Clone, Debug, PartialEq, Encode, TypeInfo, ReflectHash)]
#[codec(crate = sails_rs::scale_codec)]
#[scale_info(crate = sails_rs::scale_info)]
#[reflect_hash(crate = sails_rs)]
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),
}

pub struct CounterService<'a> {
    data: &'a RefCell<CounterData>,
}

impl<'a> CounterService<'a> {
    // Service constrctor demands a reference to the data to be passed
    // from the outside.
    pub fn new(data: &'a RefCell<CounterData>) -> Self {
        Self { data }
    }
}

// Declare the service can emit events of type CounterEvents.
#[service(events = CounterEvents)]
impl CounterService<'_> {
    /// Add a value to the counter
    #[export]
    pub fn add(&mut self, value: u32) -> u32 {
        let mut data_mut = self.data.borrow_mut();
        data_mut.counter += value;
        // Emit event right before the method returns via
        // the generated `emit_event` method.
        self.emit_event(CounterEvents::Added(value)).unwrap();
        data_mut.counter
    }

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

    /// Get the current value
    #[export]
    pub fn value(&self) -> u32 {
        self.data.borrow().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<'_> {
        CounterService::new(&self.counter_data)
    }
}

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

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);
}