Operaciones matemáticas de Cosmowasm

Explicación

En esta sección, puede ver ejemplos de un contrato CosmWasm que implementa operaciones matemáticas simples como suma, resta, multiplicación, división, módulo y exponencial.

La siguiente función de ejecución toma una enumeración de ExecuteMsg que en realidad contiene todas las funciones del contrato y las relaciona con la función que llama el usuario:

pub fn execute(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
    ExecuteMsg::Operations { a, b } => execute_operations(deps,a,b),
}
}

La función de ejecución toma una enumeración de ExecuteMsg que en realidad contiene todas las funciones del contrato y las relaciona con la función que el usuario está llamando, y luego llama a la función ejecutar_operaciones:

pub fn execute_operations(deps: DepsMut, a: u128, b: u128) -> Result<Response, ContractError> {
        // Checking if numbers are not zero
        if a == 0 && b == 0 {
            return Err(ContractError::CanNotBeZero());
        }
        // Addition
        let addition_result = a + b;
        // Subtraction
        let subtraction_result = a - b;
        // Multiplication
        let multiplication_result = a * b;
        // Division
        let division_result = a / b;
        // Modulo
        let modulo_result = a % b;
        // Exponentiation
        let exponent: u32 = 3;
        let exponentiation_result: u128 = a.pow(exponent);
        // Create the response
        let response = OperationsResponse {
            addition_result,
            subtraction_result,
            multiplication_result,
            division_result,
            modulo_result,
            exponentiation_result,
        };
        // Fetching the state
        RESULT.load(deps.storage).unwrap();
        // Update the state
        RESULT.save(deps.storage, &response).unwrap();
        let res = Response::new().add_attributes(vec![
            ("action", "operations"),
            ("a", &a.to_string()),
            ("b", &b.to_string()),
            ("addition_res", &addition_result.to_string()),
            ("substraction_res", &subtraction_result.to_string()),
            ("multiplicationn_res", &multiplication_result.to_string()),
            ("division_res", &division_result.to_string()),
            ("modulo_res", &modulo_result.to_string()),
            ("exponential_res", &exponentiation_result.to_string()),
        ]);
        Ok(res)
    }

La función execute_operations toma dos parámetros a y b para operaciones matemáticas y almacena el resultado en la variable de estado global RESULT almacenada en state.rs:

pub const RESULT: Item<OperationsResponse> = Item::new("result");

Puede utilizar el siguiente punto final de consulta para obtener el resultado de operaciones matemáticas: .

pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<QueryResponse, StdError> {
    match msg {
        QueryMsg::GetResponse {} => get_response(deps),
    }
}

La función de consulta anterior toma una enumeración de QueryMsg que en realidad contiene todas las funciones de consulta del contrato y las relaciona con la función que llama el usuario. En nuestro caso GetResponse. Luego llama a la función get_response:

pub fn get_response(deps: Deps) -> Result<QueryResponse, StdError> {
    let result = RESULT.load(deps.storage)?;
    to_binary(&result)
}

La función get_response anterior devuelve el resultado de la operación matemática.

Ejemplo

Para utilizar operaciones matemáticas con CosmWasm, puede crear los siguientes archivos: lib.rs contract.rs msg.rs error.rs state.rs

lib.rs

pub mod contract;
mod error;
pub mod msg;
pub mod state;
pub use crate::error::ContractError;

contract.rs

#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{
    to_binary, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, StdError,
};
use cw2::set_contract_version;
use crate::error::ContractError;
use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
use crate::state::{OperationsResponse, RESULT};
// version info for migration info
const CONTRACT_NAME: &str = "crates.io:cosmwasm-math";
const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
    /* Deps allows to access:
    1. Read/Write Storage Access
    2. General Blockchain APIs
    3. The Querier to the blockchain (raw data queries) */
    deps: DepsMut,
    /* env gives access to global variables which represent environment information.
    For exaample:
    - Block Time/Height
    - contract address
    - Transaction Info */
    _env: Env,
    /* Message Info gives access to information used for authorization.
    1. Funds sent with the message.
    2. The message sender (signer). */
    _info: MessageInfo,
    _msg: InstantiateMsg,
) -> Result<Response, ContractError> {
    /* Instantiating the state that will be stored to the blockchain */
    let operation_response = OperationsResponse {
        addition_result: 0,
        subtraction_result: 0,
        multiplication_result: 0,
        division_result: 0,
        modulo_result: 0,
        exponentiation_result: 0,
    };
    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION).unwrap();
    // Save the stete in deps.storage which creates a storage for contract data on the blockchain.
    RESULT.save(deps.storage, &operation_response).unwrap();
    Ok(Response::new().add_attribute("method", "instantiate"))
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::Operations { a, b } => execute::execute_operations(deps, a, b),
    }
}
pub mod execute {
    use super::*;
    pub fn execute_operations(deps: DepsMut, a: u128, b: u128) -> Result<Response, ContractError> {
        // Checking if numbers are not zero
        if a == 0 && b == 0 {
            return Err(ContractError::CanNotBeZero());
        }
        // Addition
        let addition_result = a + b;
        // Subtraction
        let subtraction_result = a - b;
        // Multiplication
        let multiplication_result = a * b;
        // Division
        let division_result = a / b;
        // Modulo
        let modulo_result = a % b;
        // Exponentiation
        let exponent: u32 = 3;
        let exponentiation_result: u128 = a.pow(exponent);
        // Create the response
        let response = OperationsResponse {
            addition_result,
            subtraction_result,
            multiplication_result,
            division_result,
            modulo_result,
            exponentiation_result,
        };
        // Fetching the state
        RESULT.load(deps.storage).unwrap();
        // Update the state
        RESULT.save(deps.storage, &response).unwrap();
        let res = Response::new().add_attributes(vec![
            ("action", "operations"),
            ("a", &a.to_string()),
            ("b", &b.to_string()),
            ("addition_res", &addition_result.to_string()),
            ("substraction_res", &subtraction_result.to_string()),
            ("multiplicationn_res", &multiplication_result.to_string()),
            ("division_res", &division_result.to_string()),
            ("modulo_res", &modulo_result.to_string()),
            ("exponential_res", &exponentiation_result.to_string()),
        ]);
        Ok(res)
    }
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<QueryResponse, StdError> {
    match msg {
        QueryMsg::GetResponse {} => query::get_response(deps),
    }
}
pub mod query {
    use super::*;
    pub fn get_response(deps: Deps) -> Result<QueryResponse, StdError> {
        let result = RESULT.load(deps.storage)?;
        to_binary(&result)
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{coins, from_binary};
    #[test]
    fn proper_initialization() {
        let mut deps = mock_dependencies();
        let msg = InstantiateMsg {};
        let info = mock_info("creator", &coins(1000, "earth"));
        // we can just call .unwrap() to assert this was a success
        let res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
        assert_eq!(0, res.messages.len());
        // it worked, let's query the state
        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetResponse {}).unwrap();
        let value: OperationsResponse = from_binary(&res).unwrap();
        assert_eq!(0, value.addition_result);
        assert_eq!(0, value.subtraction_result);
        assert_eq!(0, value.multiplication_result);
        assert_eq!(0, value.division_result);
        assert_eq!(0, value.modulo_result);
        assert_eq!(0, value.exponentiation_result);
    }
    #[test]
    fn increment() {
        let mut deps = mock_dependencies();
        let msg = InstantiateMsg {};
        let info = mock_info("creator", &coins(2, "token"));
        let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
        // testing operation function
        let info = mock_info("anyone", &coins(2, "token"));
        let msg = ExecuteMsg::Operations { a: 5, b: 5 };
        let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
        // should get basic math operation for 5 and 5
        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetResponse {  }).unwrap();
        let value: OperationsResponse = from_binary(&res).unwrap();
        assert_eq!(10, value.addition_result);
        assert_eq!(0, value.subtraction_result);
        assert_eq!(25, value.multiplication_result);
        assert_eq!(1, value.division_result);
        assert_eq!(0, value.modulo_result);
        assert_eq!(125, value.exponentiation_result);
    }
}

msg.rs

use cosmwasm_schema::{cw_serde, QueryResponses};
#[cw_serde]
pub struct InstantiateMsg {}
#[cw_serde]
pub enum ExecuteMsg {
    Operations { a: u128, b: u128 },
}
#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
    #[returns(u128)]
    GetResponse {},
}

error.rs

use thiserror::Error;
#[derive(Error, Debug)]
pub enum ContractError {
    #[error("Numbers can not be zero")]
    CanNotBeZero(),
}

state.rs

use cosmwasm_schema::cw_serde;
use cw_storage_plus::Item;
#[cw_serde]
pub struct OperationsResponse {
    pub addition_result: u128,
    pub subtraction_result: u128,
    pub multiplication_result: u128,
    pub division_result: u128,
    pub modulo_result: u128,
    pub exponentiation_result: u128,
}
// Mapping of result of two numbers
pub const RESULT: Item<OperationsResponse> = Item::new("result");