Getting Started

-- daml/Main.daml
module Main where

-- A simple counter that can be incremented
template Counter
  with
    owner : Party
    count : Int
  where
    signatory owner

    -- Increment the counter
    choice Increment : ContractId Counter
      controller owner
      do
        create this with count = count + 1

    -- Reset to zero
    choice Reset : ContractId Counter
      controller owner
      do
        create this with count = 0

    -- Get current value (non-consuming)
    nonconsuming choice GetValue : Int
      controller owner
      do
        return count

-- Test script
testCounter : Script ()
testCounter = script do
  alice <- allocateParty "Alice"

  -- Create counter starting at 0
  cid <- submit alice do
    createCmd Counter with
      owner = alice
      count = 0

  -- Increment 3 times
  cid <- submit alice do exerciseCmd cid Increment
  cid <- submit alice do exerciseCmd cid Increment
  cid <- submit alice do exerciseCmd cid Increment

  -- Check value
  value <- submit alice do exerciseCmd cid GetValue
  assert (value == 3)

  -- Reset
  cid <- submit alice do exerciseCmd cid Reset

  -- Verify reset
  Some counter <- queryContractId alice cid
  assert (counter.count == 0)

// src/contract.rs
use cosmwasm_std::{
    entry_point, to_json_binary, Binary, Deps, DepsMut,
    Env, MessageInfo, Response, StdResult,
};
use cw_storage_plus::Item;
use serde::{Deserialize, Serialize};

const COUNT: Item = Item::new("count");

#[derive(Serialize, Deserialize)]
pub struct InstantiateMsg {
    pub initial_count: i32,
}

#[derive(Serialize, Deserialize)]
pub enum ExecuteMsg {
    Increment {},
    Reset {},
}

#[derive(Serialize, Deserialize)]
pub enum QueryMsg {
    GetCount {},
}

#[derive(Serialize, Deserialize)]
pub struct CountResponse {
    pub count: i32,
}

#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult {
    COUNT.save(deps.storage, &msg.initial_count)?;
    Ok(Response::new()
        .add_attribute("action", "instantiate")
        .add_attribute("count", msg.initial_count.to_string()))
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: ExecuteMsg,
) -> StdResult {
    match msg {
        ExecuteMsg::Increment {} => {
            let count = COUNT.load(deps.storage)?;
            COUNT.save(deps.storage, &(count + 1))?;
            Ok(Response::new().add_attribute("action", "increment"))
        }
        ExecuteMsg::Reset {} => {
            COUNT.save(deps.storage, &0)?;
            Ok(Response::new().add_attribute("action", "reset"))
        }
    }
}

#[entry_point]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult {
    match msg {
        QueryMsg::GetCount {} => {
            let count = COUNT.load(deps.storage)?;
            to_json_binary(&CountResponse { count })
        }
    }
}