Smart Contracts

bwickchain supports CosmWasm smart contracts - Rust-based programs that run on the blockchain, similar to Solana programs.

Why CosmWasm?

Rust Safety

Memory-safe language prevents common vulnerabilities

Familiar to Solana Devs

Rust-based like Solana programs

Rich Ecosystem

CW20, CW721, and many more standards

IBC Compatible

Cross-chain contracts via IBC

Contract Lifecycle

┌─────────────┐     ┌───────────────┐     ┌─────────────┐     ┌─────────────┐
│  Scaffold   │────▶│    Build      │────▶│   Deploy    │────▶│  Interact   │
│  (bwick init) │     │(bwick program   │     │(bwick program │     │(execute/    │
│             │     │    build)     │     │   deploy)   │     │   query)    │
└─────────────┘     └───────────────┘     └─────────────┘     └─────────────┘
  1. Scaffold - Create project structure with bwick init
  2. Build - Compile Rust to optimized Wasm with bwick program build
  3. Deploy - Upload and instantiate with bwick program deploy
  4. Interact - Execute methods and query state

Commands

CommandDescription
bwick initScaffold new contract project
bwick program buildCompile to optimized Wasm
bwick program deployUpload and instantiate contract
bwick program executeCall contract method
bwick program queryRead contract state
bwick program listList deployed contracts
bwick program infoContract details
bwick localnetLocal development network

Quick Start

1. Start Local Network

bwick localnet start

2. Scaffold Project

bwick init my-contract
cd my-contract

3. Build Contract

bwick program build

4. Deploy

bwick program deploy artifacts/my_contract.wasm --from alice --label "My Contract"

5. Interact

# Query state
bwick program query bwick1contract... '{"get_count":{}}'

# Execute method
bwick program execute bwick1contract... '{"increment":{}}' --from alice

Project Structure

bwick init creates:
my-contract/
├── Cargo.toml           # Rust dependencies
├── src/
│   ├── lib.rs          # Contract entry point
│   ├── contract.rs     # Main logic
│   ├── msg.rs          # Message types
│   ├── state.rs        # State storage
│   └── error.rs        # Custom errors
├── .gitignore
└── README.md

Key Files

FilePurpose
lib.rsExports contract entry points
contract.rsinstantiate, execute, query functions
msg.rsInstantiateMsg, ExecuteMsg, QueryMsg
state.rsStorage using cw-storage-plus
error.rsCustom error types

Contract Entry Points

Every CosmWasm contract has three entry points:
// Called once when contract is created
pub fn instantiate(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> Result<Response, ContractError>

// Called to modify state
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError>

// Called to read state (no state changes)
pub fn query(
    deps: Deps,
    env: Env,
    msg: QueryMsg,
) -> StdResult<Binary>

Message Types

InstantiateMsg

Configuration when creating the contract:
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct InstantiateMsg {
    pub count: i32,
    pub owner: String,
}

ExecuteMsg

Actions that modify state:
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum ExecuteMsg {
    Increment {},
    Decrement {},
    Reset { count: i32 },
}

QueryMsg

Read-only requests:
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub enum QueryMsg {
    GetCount {},
    GetOwner {},
}

Gas & Fees

CosmWasm operations use more gas than standard transactions:
OperationTypical Gas
Store (upload)1,000,000 - 5,000,000
Instantiate200,000 - 500,000
Execute100,000 - 300,000
QueryFree (no tx)
The CLI automatically estimates gas with a 1.3x buffer.

Development Workflow

1

Write Code

Modify src/contract.rs with your logic
2

Build

bwick program build
3

Test Locally

bwick localnet start --reset
bwick program deploy artifacts/my_contract.wasm --from alice
4

Iterate

Repeat until working correctly
5

Deploy to Testnet

bwick config set node tcp://rpc.testnet.bwick.com:26657
bwick program deploy artifacts/my_contract.wasm --from mykey

Standards

Common contract standards available:
StandardDescriptionUse Case
CW20Fungible tokensToken creation
CW721Non-fungible tokensNFTs
CW1Proxy contractsUpgradability
CW3MultisigDAOs, shared wallets
CW4GroupsMembership management

Resources

Next Steps

Scaffolding

Create your first project

Building

Compile to optimized Wasm

Deploying

Deploy to the chain

Localnet

Local development network