basic page new

src/basics.md

@@ -2,32 +2,50 @@
 
 In this chapter, we will go through creating essential smart contracts step by step. I will explain the core ideas behind CosmWasm and the typical contract structure.
 
-### Creating a Rust Project for CosmWasm Smart Contracts
-
-Developing smart contracts for the CosmWasm platform requires a structured approach, starting from setting up a Rust project. This dedicated guide will walk you through creating a Rust library crate designed to work as a CosmWasm smart contract, including configuring the cargo.toml file to meet the requirements of compiling to WebAssembly (Wasm), the format needed for deploying on the CosmWasm platform.
-
-### Step 1: Initialize Your Rust Library
-
-You'll need to create a new Rust library to kick off your smart contract development. Open your terminal and execute the following command, which creates a new directory named empty-contract and initializes a Rust project configured as a library:
-
-cargo new --lib ./empty-contract
-
-This command sets up a basic Rust project structure, including a Cargo. The toml file will be used to manage your project's settings and dependencies, and a src directory will be used where your Contract's Rust source code will reside.
-
-### Step 2: Configuring the Cargo.toml file
-
-After setting up your project, the next crucial step is configuring the cargo.toml file. This file resides at the root of your project and dictates how your project is built. Navigate to the empty-contract directory and open the cargo.toml file in your preferred editor to make the following adjustments:
-
-[package] name = "contract" version = "0.1.0" edition = "2021" [lib] crate-type = ["cdylib"] [dependencies] cosmwasm-std = { version = "1.0.0-beta8", features = ["staking"] }
-
-### Explanation of Key Configurations:
-
-- **[package]**: This section defines basic metadata about your project. The edition field specifies which edition of Rust you are targeting, with "2021" being the most recent as of this writing.
-- **[lib]**: By specifying crate-type as ["cdylib"], you are instructing Rust to compile your library into a dynamic library, specifically a WebAssembly (Wasm) binary. This is required for the Contract to run in the CosmWasm environment. Note that this configuration means the compiled library cannot be included as a dependency in other Rust crates.
-- **[dependencies]**: The cosmwasm-std dependency is essential for smart contract development on the CosmWasm platform. It acts as the standard library, providing the types, functions, and utilities necessary to interact with the blockchain. The version should be the latest stable version compatible with your project's requirements, and the features field enables specific functionalities, such as staking in this case, which may be necessary depending on your Contract's use case.
-
-### Final Steps:
-
-With your Rust project correctly configured, you can start writing your smart contract code within the src/lib.rs file. This involves implementing the Contract's logic, including handling initialization, execute, and query operations according to the CosmWasm standard.
-
-As you develop your smart Contract, regularly compile and test your code to ensure that it meets the expected functionalities and security standards required for deployment on the blockchain. Utilizing the comprehensive tooling and resources available in the Rust and CosmWasm communities will aid in this process, helping you to develop robust, efficient, and secure smart contracts.
+### **Introduction to CosmWasm**
+
+**How to Understand Core Concepts:**
+
+- **Wasm**: Experiment with compiling simple Rust programs to WebAssembly to understand the compilation process. Tools like **`wasm-pack`** can help in this learning phase.
+- **Interoperability**: Explore the Cosmos SDK documentation and IBC protocol to grasp how CosmWasm facilitates cross-chain interactions. Look for simple IBC examples or tutorials to see this in action.
+- **Rust Programming Language**: If new to Rust, start with "The Rust Programming Language" book (often referred to as "The Book") available for free online. Rust's ownership model and safety guarantees are crucial for writing secure smart contracts.
+
+### **Typical Contract Structure**
+
+1. **Contract Entry Points**
+
+    **How to Implement Entry Points:**
+
+    - **Instantiate**: Begin by defining what initial state your contract will have. Implement the **`instantiate`** function to set initial values, ensuring to handle any necessary input validation.
+    - **Execute**: Identify the actions your contract must support. Implement each action as a case within the **`execute`** function, manipulating the contract's state as required.
+    - **Query**: Determine the data users might need to read from your contract. Implement the **`query`** function to return this data, ensuring no state modification occurs.
+2. **Messages**
+
+    **How to Define Messages:**
+
+    - Use Rust's **`enum`** and **`struct`** to define messages. Each action your contract supports will be a variant in the **`ExecuteMsg`** enum. Similarly, define **`InstantiateMsg`** and **`QueryMsg`** based on what data they must carry.
+3. **State Management**
+
+    **How to Manage State:**
+
+    - Design your state model carefully, considering how data is accessed and updated. Use the **`DepsMut`** for state mutations and **`Deps`** for state queries. Implement helper functions for common state operations to encapsulate the storage access patterns.
+4. **Dependencies**
+
+    **How to Handle Dependencies:**
+
+    - Familiarize yourself with the **`cosmwasm_std`** library's API by reading the documentation and looking at example contracts. For external crates, ensure they support compilation to **`wasm32-unknown-unknown`** target.
+
+### **Step-by-Step Guide to Creating a Smart Contract**
+
+1. **Setup**
+    - Install Rust and **`cargo`** using rustup. Set up your IDE for Rust development (VSCode, IntelliJ, etc.). Create a new project using **`cargo new --lib your_contract_name`**.
+2. **Define Messages**
+    - Sketch out the functionality of your contract. For each function, define a message in Rust, using structs for data and enums for differentiating message types.
+3. **Implement Entry Points**
+    - Start with the **`instantiate`** function for setting the initial state. Proceed to **`execute`** where you'll handle different messages as per your contract's logic. Finally, implement **`query`** for data retrieval.
+4. **State Management**
+    - Use the **`cosmwasm_std::Storage`** trait for state management. Design your key-value schema and implement getter and setter functions for interacting with the state.
+5. **Business Logic**
+    - Flesh out the business logic within the **`execute`** function. Consider edge cases and input validation to ensure contract security and reliability.
+6. **Testing**
+    - Write unit tests for each entry point and critical functions within your contract. Use **`cargo test`** to run your tests. Consider edge cases and invalid inputs to ensure your contract behaves as expected under various conditions.