cw-cyber/contracts/hub-tokens/src/contract.rs

#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult};
use cw2::{get_contract_version, set_contract_version};

use crate::execute::{execute_create_entry, execute_update_entry, execute_update_owner};
use crate::msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
use crate::query::{query_entry, query_list};
use crate::state::LIST;
use hub_base::ContractError;

const CONTRACT_NAME: &str = "hub-tokens";
const CONTRACT_VERSION: &str = "0.1.0";

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> Result<Response, ContractError> {
    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
    let (_config, response) = hub_base::execute::instantiate(deps, info, msg.owner)?;
    Ok(response)
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::UpdateOwner { new_owner } => execute_update_owner(deps, env, info, new_owner),
        ExecuteMsg::CreateEntry {
            ticker,
            chain_id,
            contract,
            decimals,
            channel_id,
            logo,
            particle,
        } => execute_create_entry(
            deps, info, ticker, chain_id, contract, decimals, channel_id, logo, particle,
        ),
        ExecuteMsg::UpdateEntry {
            id,
            ticker,
            chain_id,
            contract,
            decimals,
            channel_id,
            logo,
            particle,
        } => execute_update_entry(
            deps, info, id, ticker, chain_id, contract, decimals, channel_id, logo, particle,
        ),
        ExecuteMsg::DeleteEntry { id } => {
            hub_base::execute::execute_delete_entry(deps, info, id, &LIST)
        }
    }
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
    match msg {
        QueryMsg::GetEntries { start_after, limit } => {
            to_json_binary(&query_list(deps, start_after, limit)?)
        }
        QueryMsg::GetEntry { id } => to_json_binary(&query_entry(deps, id)?),
    }
}

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn migrate(deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
    let version = get_contract_version(deps.storage)?;
    if version.contract != CONTRACT_NAME {
        return Err(ContractError::CannotMigrate {
            previous_contract: version.contract,
        });
    }
    Ok(Response::default())
}