Skip to main content

Develop Your First Cron Service

Intent solver bot is a strategy. Refer to concepts here

Installation​

  • Install rust toolchain, add environment wasm32-unknown-unknown
  • Golang 1.21 and an IDE

See installations for more details

Example context​

This example demonstrates how to write a bank transfer Cron Service. The Cron Service receives this input:

{
  "receiver": "[acc-address]",
  "amount": "[amount]",
  "denom": "[denom]"
}

Cron Service will be executed approximately every timestamp interval, which is configured when we deploy or update it.

Let's code​

Init project​

Let's name the project bank-cron

mkdir bank-cron && bank-cron
cargo init --lib

Folder structure:

├── Cargo.toml
└── src
    └── lib.rs

Configure Cargo.toml​

Use this template with this basic example, later on, feel free to customize it for specific need

[package]
name = "bank-cron"
version = "0.0.1"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
cosmwasm-std = "2.0.1"
serde = { version = "1.0.145", default-features = false, features = ["derive"] }
cosmwasm-schema = "2.0.1"

[lib]
crate-type = ["cdylib", "rlib"]

[features]
# use library feature to disable all instantiate/execute/query exports
library = []

Coding​

use cosmwasm_schema::cw_serde;
use cosmwasm_std::{entry_point, to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult, from_json};
use std::{vec::Vec};

#[cw_serde]
pub struct InstantiateMsg {}

#[cw_serde]
pub enum ExecuteMsg {}

#[cw_serde]
pub struct QueryMsg {
    msg: Binary,
    fis_input: Vec<FisInput>
}

#[cw_serde]
pub struct FisInput {
    data: Vec<Binary>
}

#[cw_serde]
pub struct CronInput {
    receiver: String,
    amount: String,
    denom: String,
}

#[cw_serde]
pub struct FISInstruction {
    plane: String,
    action: String,
    address: String,
    msg: Vec<u8>,
}

#[cw_serde]
pub struct StrategyOutput {
    instructions: Vec<FISInstruction>,
}

#[cw_serde]
pub struct MsgSend {
    from_address: String,
    to_address: String,
    amount: Vec<BankAmount>,
}

#[cw_serde]
pub struct BankAmount {
    denom: String,
    amount: String,
}

#[entry_point]
pub fn instantiate(
    _deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    _msg: InstantiateMsg,
) -> StdResult<Response> {
    Ok(Response::new().add_attribute("method", "instantiate"))
}

#[entry_point]
pub fn execute(
    _deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    _msg: ExecuteMsg,
) -> StdResult<Response> {
    Ok(Response::new().add_attribute("method", "execute"))
}

#[entry_point]
pub fn query(_deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
    // parse cron input
    let command = from_json::<CronInput>(msg.msg)?;

    // parse command, we can store it as proto bytes, encrypted binary
    let mut instructions = vec![];

    // send usdt
    instructions.push(FISInstruction {
        plane: "COSMOS".to_string(),
        action: "COSMOS_BANK_SEND".to_string(),
        address: "".to_string(),
        msg: to_json_binary(&MsgSend {
            from_address: env.contract.address.clone().into_string(),
            to_address: command.receiver.to_string(),
            amount: vec![BankAmount {
                denom: command.denom.to_string(),
                amount: command.amount.to_string(),
            }],
        })
        .unwrap()
        .to_vec(),
    });

    Ok(to_json_binary(&StrategyOutput { instructions }).unwrap())
}

Code components​

Since Cron Service make use of strategy, they shares same definitions, see strategy code components

Deploy Cron Service​

Assume we are in bank-cron folder, let's copy bank_cron.wasm to sdk-go as cron.wasm

cp target/wasm32-unknown-unknown/release/bank_cron.wasm ../sdk-go/examples/chain/26_MsgConfigCron/cron.wasm
cd ../sdk-go
yes 12345678 | go run examples/chain/26_MsgConfigCron/example.go

Congratulations! Now you know how to build a Cron Service bot on Flux Astromesh. Happy building!