DEV Community: Vu

Home Lab Networking

Vu — Mon, 09 Sep 2024 03:40:54 +0000

Hi folks, welcome to my tutorial for building Homelab. In this part, I will cover some setup I am setting on my server.

Of course, I need to plan a network. I haven't setup a network before, so this is one of the challenges for me.

flowchart TD;
    I[Internet]
    I1[GPON]
    I2[Main Router </br> 192.168.100.1]

    subgraph P1[Proxmox Server]
        P2[Physic Port Network </br> IP: 192.168.100.2/24]
        P3[Logical Network </br> IP: 192.168.100.2/24]

        subgraph vmbr0[vmbr0 Open vSwitch]
            LXC1[AdguardHome </br>192.168.100.x]
            LXC2[Pihole </br>192.168.100.x]
            LXC3[Dockerlxc </br>192.168.100.x]
        end 

        VM1[pfSense VM Firewall]

        subgraph vmbr1[vmbr1 Open vSwitch]
            VM2[VM </br> 10.0.50.x]
            VM3[VM </br> 10.0.70.x]
            VM4[VM </br> 10.0.24.x]
        end 
    end



    I --Optical_fiber--> I1
    I1 --RJ45--> I2
    I2 --RJ45--> P2
    P2 --hypervisor--> P3
    P3 --> LXC1
    P3 --> LXC2
    P3 --> LXC3
    P3 ----> VM1[pfSense VM Firewall </br> WAN/vtnet0: 192.168.100.147 </br> </br> LAN/vtnet1: 10.0.1.1/24 </br> </br> LAN/vtnet1.50: 10.0.50.1/24 </br> </br> LAN/vtnet1.70:1.70: 10.0.70.1/24 </br> </br> LAN/vtnet1.24: 10.0.24.1/24]

    VM1 --vlan1.50--> VM2
    VM1 --vlan1.70--> VM3
    VM1 --vlan1.24--> VM4

And this is my network diagram, let's break down it:

Internet.
GPON(fiber).
Main router.
- For wifi and port forwarding.
Proxmox server on MS-01.
vmbr0 (Open vSwitch).
- Bridged to the logical interface
- Any VMs attached to this virtual switch will be on your home router’s LAN
Virtual pfSense firewall
- WAN Port (vtnet0 interface)
  - This is not a public IP, but rather a private IP on your home router’s LAN
  - Attached to VMBR0
  - Allows traffic to get out to the LAN and to the Internet via your home router’s WAN port
- LAN Port (vtnet1 interface)
  - Provides another virtual LAN for VMBR1
  - Firewall rules will dictate how traffic is routed between subnets
  - VLANs are defined as sub-interfaces on vtnet1
    - vtnet1 (native): 10.0.1.0/24
      - Any machine that is not tagged with a VLAN.
    - vtnet1.50 - 10.0.50.0/24
      - Sec egress network.
    - vtnet1.70 - 10.0.70.0/24
      - Private VMs.
    - vtnet1.345 - 10.0.24.0/24
      - Net for testing purposes.
vmbr1 (Open vSwitch)
- Connect to pfSense LAN port.
- Any VM, LXC will be connected to it, we can define the VLAN tags.

Why do we need it?

I haven't used the firewall before, so this is my first time and I want to use to firewall (pfSense or OPNsense).
I don't have a physical switch with trunk ports so I can use it in the pfSense virtual.
You have only one network in card (NIC) such as laptop.

Reference

Special thanks Benheter for detail the blog that I can follow and implement.

Smartcontract with CosmWasm (Part 5)

Vu — Sat, 24 Sep 2022 16:23:42 +0000

Introduction

I come back after work personal. Thanks to everyone following and supporting me and that's the end of the series.

Build the contract

We need to define the schema of the contract in the file examples/schema.rs. Import all schemas we have from previous part as: State, InstantiateMsg, ExecuteMsg, QueryMsg, ExecuteResponse, QueryResponse:

use std::env::current_dir;
use std::fs::create_dir_all;

use cosmwasm_schema::{export_schema, remove_schemas, schema_for};

use cw_starter::msg::{ExecuteMsg, ExecuteResponse, InstantiateMsg, QueryMsg, QueryResponse};
use cw_starter::state::State;

fn main() {
    let mut out_dir = current_dir().unwrap();
    out_dir.push("schema");
    create_dir_all(&out_dir).unwrap();
    remove_schemas(&out_dir).unwrap();

    export_schema(&schema_for!(State), &out_dir);
    export_schema(&schema_for!(InstantiateMsg), &out_dir);
    export_schema(&schema_for!(ExecuteMsg), &out_dir);
    export_schema(&schema_for!(ExecuteResponse), &out_dir);
    export_schema(&schema_for!(QueryMsg), &out_dir);
    export_schema(&schema_for!(QueryResponse), &out_dir);
}

We push all json schema to the schema directory. Now, we generate our schemas
Run command in the terminal in the root our folder:

cargo schema

After the command runs successfully, we will see the json schemas in the schema folder.

The preparation step is alright. Next, build the smart contract with CosmWasm IDE.

Open the file src/contract.rs and click Build CosmWasm in the status bar and wait for the extension to build our contract. After the building has been done, we find a new file: artifacts/cw-starter.wasm and the UI of the extension will appear. This is our contract:

Note: We are using these dependencies in Cargo.toml, so we need to choose the chain support our contract as: Malaga, Osmosis Testnet, Osmosis Mainnet and CosmosHub Testnet and add your mnemonic to the file .env in the root project for extension to read mnemonic and interact with your wallet.

[dependencies]
cosmwasm-std = "1.0.0"
cosmwasm-storage = "1.0.0"
cw-storage-plus = "0.13.2"
cw2 = "0.13.2"
schemars = "0.8.8"
serde = { version = "1.0.137", default-features = false, features = ["derive"] }
thiserror = { version = "1.0.31" }

Alright, we move to the next step: Deploy the contract on the chain.

Deploy the contract

First of all, select the chain, I will choose the Osmosis Testnet.
We need complete all fields when deploying the contract. In our case, the InstantiateMsg doesn't need any field, so we only need to input the label of the contract or you can ignore it.

Let's deploy with the Deploy CosmWasm and wait for our contract StoreCode and Instantiate to the chain. After deployment success, we have a contract address.

Execute the contract

Open the select box and choose Execute, input the contract address we get from the above step and the following message in the Execute Message input.
Need input your mnemonic in the wallet mnemonic(optional) (I know that is confusing, but it is required).

{"update":{}}

Press the Execute button. The extension will execute our contract and return the transaction containing msg execute the contract.

Query the contract

Same execute the contract, I will move fast:
Select the Query, input our contract address and input the Query Message:

{"counter":{}}

Press the Query button and tada! And the current state of the contract will appear.

Summary

That's the end of the series. I hope after this series, we have a simple term, development code and interact with CosmWasm Smart Contract.
Thanks for reading.

Reference

Writing a smart contract with CosmWasm (Part 4)

Vu — Tue, 13 Sep 2022 14:57:18 +0000

Introduction

Continue with my series, we will perform query.
The query is an action in order to get data from the contract.

Create message query smart contracts

Same as execute, we need to define two structs QueryMsg and QueryResponse in the src/msg.rc to visualize the data type we want to receive and respond. Insert the below code:




#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
    Counter {},
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct QueryResponse {
    pub counter: i32,
}

QueryResponse is response of the smart contract return when we perform query with QueryMsg. Same as the response from API, it returns json data.

Next, create a file: query.rs in the src folder and import module query to lib.rs. Our lib.rs will show:



pub mod contract;
mod error;
pub mod execute;
pub mod msg;
pub mod query;
pub mod state;

pub use crate::error::ContractError;

In the file query.rs, we are implementing a function with the name query_counter and we pass the deps as a parameter. The function return a StdResult<Binary>. Update the below code:



#[cfg(not(feature = "library"))]
use cosmwasm_std::{to_binary, Binary, Deps, Env, StdResult};

use crate::msg::QueryResponse;
use crate::state::STATE;

pub fn query_counter(deps: Deps, _env: Env) -> StdResult<Binary> {
    let current_state = STATE.load(deps.storage)?;
    let counter = current_state.counter;

    let resp = to_binary(&QueryResponse { counter }).unwrap();
    Ok(resp)
}

That's right. Simple, we implement a logic to query data stored in smart contract.
We need to bind response to json data with to_binary function support from cosmwasm-std.
And don't forget add an new entry point to src/contract.rs:



#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
    match msg {
        QueryMsg::Counter {} => query_counter(deps, env),
    }
}

I think we have familiar with this syntax throughout of series.
The last entry point of our contract has appeared. We need to test it.

Testing module

Still in the file: src/query.rs. and update the below code to bottom:



#[cfg(test)]
mod tests {
    use crate::contract::{execute, instantiate, query};
    use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg, QueryResponse};
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::to_binary;

    const ADDR: &str = "addr1";

    #[test]
    fn test_query() {
        let mut deps = mock_dependencies();
        let env = mock_env();
        let info = mock_info(ADDR, &[]);
        let expect_data_0 = to_binary(&QueryResponse { counter: 0 }).unwrap();
        let expect_data_1 = to_binary(&QueryResponse { counter: 1 }).unwrap();

        let msg = InstantiateMsg {};
        let _resp = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();

        // query one time.
        let msg = QueryMsg::Counter {};
        let resp = query(deps.as_ref(), env.clone(), msg).unwrap();
        assert_eq!(resp, expect_data_0);

        // query two time
        let msg = ExecuteMsg::Update {};
        let _resp = execute(deps.as_mut(), env.clone(), info, msg).unwrap();
        let msg = QueryMsg::Counter {};
        let resp = query(deps.as_ref(), env, msg).unwrap();
        assert_eq!(resp, expect_data_1);
    }
}

In query testing module, we will coverage all logic of the smart contract includes: create contract, execute contract, and query contract.

We create a module test and unit test function test_query.
We still import all dependencies and create two values expected. One for getting state after instantiate contract, two for getting state after execute the contract.

Run cargo-test in the terminal

If your output like below, everything is right:



running 1 test

test query::tests::test_query ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s

Sumary

I mentioned all entry points of the smart contract, wrote logic attach test case for our logic of smart contract.
Next part, I will build and deploy our contract to testnet network.
Thanks for reading and have a good day!

Writing a smart contract with CosmWasm (Part 3)

Vu — Sat, 10 Sep 2022 15:45:33 +0000

Introduction

Welcome back to my series. Sorry for this belated, we will discover the execute contract in this part.
In the previous part, I explained that execute will change the smart contract data.
Let's implement this.

Create the message to execute smart contracts.

First, we need to define the ExecuteMsg and ExecuteResponse by updating the following code in the src/msg.rs:

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
    Update {},
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct ExecuteResponse {
    pub counter: i32,
}

ExecuteMsg is an enum and has an Updates arm. This arm is simply to help counter variable increment 1 when we execute the contract.

Let's create a file: execute.rs in the src folder. Our logic will be in this file.
First, import module execute to lib.rs

We are implementing a function with the name try_update_counter (don't use camel case, convention in rust use dash to connect word in name of function or variable) and we pass the deps as a parameter. The function return a Result<Response, ContractError>. All logic of function will be as below:

#[cfg(not(feature = "library"))]
use cosmwasm_std::{to_binary, DepsMut, Response};

use crate::error::ContractError;
use crate::msg::ExecuteResponse;
use crate::state::{State, STATE};

pub fn try_update_counter(deps: DepsMut) -> Result<Response, ContractError> {
    let current_state = STATE.load(deps.storage)?;
    let mut current_counter = current_state.counter;

    current_counter += 1;

    let new_state = State {
        counter: current_counter,
    };
    STATE.save(deps.storage, &new_state)?;

    let resp = to_binary(&ExecuteResponse {
        counter: current_counter,
    })
    .unwrap();
    Ok(Response::new().set_data(resp))
}

Yea, I think it's easy to read and understand: we get the counter in the current state of the contract current.counter, increment it by 1 and save it in the contract's store again, return it as a response.

But we have a wonder: where to implement try_update_counter. We need to open src / contract.rs and update it with the function below the immediate second entry point.

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {
    match msg {
        ExecuteMsg::Update {} => try_update_counter(deps),
    }
}

Alright, we have implemented the second entry point of our contract! Don't forget to test the logic!
Next to the Testing module section.

Testing module

Still in the file: execute.rs. and update the below code to bottom:

#[cfg(test)]
mod tests {
    use crate::contract::{execute, instantiate};
    use crate::msg::{ExecuteMsg, ExecuteResponse};
    use crate::state::STATE;

    use crate::msg::InstantiateMsg;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::to_binary;

    const ADDR: &str = "addr";

    #[test]
    fn test_execute() {
        let mut deps = mock_dependencies();
        let env = mock_env();
        let info = mock_info(ADDR, &[]);
        let expect_data = to_binary(&ExecuteResponse { counter: 1 }).unwrap();
        let expect_number = 2;

        // instantiate msg
        let msg = InstantiateMsg {};
        let _resp = instantiate(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();

        // execute one time
        let msg = ExecuteMsg::Update {};
        let resp = execute(deps.as_mut(), env.clone(), info.clone(), msg).unwrap();
        println!("Execute once!");
        assert_eq!(resp.data, Some(expect_data));

        // execute two time
        let msg = ExecuteMsg::Update {};
        let _resp = execute(deps.as_mut(), env, info, msg);
        let current_state = STATE.load(deps.as_mut().storage).unwrap();
        println!("Execute twice!");
        assert_eq!(current_state.counter, expect_number);
    }
}

We create a module test and unit test function test_execute.
We still import all dependencies and create two values, one for a response from try_update_counter is expected_data and one compare with our state is expected_number.

We also import InstantiateMsg to create our state, of cause, counter will be 0.
One time to execute, we call execute function, update counter equal 1 and assert_eq resp.data with expect_data
Two time to execute, we also call execute function, update counter equal 2 and assert_eq current_state.counter with expect_number.

Very simple to understand.

Run cargo-test in the terminal

If your output is like the below, everything is right:

running 2 tests
test contract::tests::test_instantiate ... ok
test execute::tests::test_execute ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests cw-starter

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

It run 1 test case, and 1 passed.

Summary

We just have created second entry point of smart contract is execute: ExecuteMsg, ExecuteResponse and try_update_counter.
We also create a module for testing this.

I will mention the last entry point naming: query in the next part.
Thanks, everyone to read the post.

Writing a smart contract with CosmWasm (Part 2)

Vu — Sun, 04 Sep 2022 02:56:17 +0000

Smart contract explain

Welcome back to my series. In this section, I will explain how smart contract work. Don't think it is difficult. Keep it easy to imagine.

The smart contract has a state - or what we call storage. We need to interact with the state by query and state.

Imagine, developing a smart contract same as we are developing a backend application API:

Smart contract	API Application	Description
State	Database	Store data for application
Query	QUERY	Get current data stored in the application
Execute	POST, PUT, DELETE	Change data stores in application

And an important component is the message, it is the way we tell the smart contract do something.
Done. We have the understanding mechanism of the smart contract. Moving to the next section, we how to create a state of the smart contract.

Create state smart contracts.

Let's start in the src/state.rs and update the file with the following code:

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use cw_storage_plus::Item;

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct State {
    pub counter: i32,
}

pub const STATE: Item<State> = Item::new("state");

I note something to give a quick overview:

JsonSchema allows structs to be serialized and deserialized to and from JSON
Deserialize and Serialize provide the serialization described above.
Item is a helper provided by storage plus. It effectively means we can store an item in storage. In this case, the STATE variable is an Item that stores a singular State struct.

We just define a schema of the state.

Instantiating a Contract

When contracts are stored on the chain, they must be instantiated.
Instantiating a contract is achieved by a special message.
First, update the src/msg.rs with the code:

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct InstantiateMsg {}

We don't need parameters when instantiating the contract in the special message InstantiateMsg.
Now let's use this message.

Instantiation

Alright, open the src/contract.rs, this is where logic happens, update the file with the following code:

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

use crate::error::ContractError;
use crate::msg::InstantiateMsg;
use crate::state::{State, STATE};

const CONTRACT_NAME: &str = "crates.io:cw-starter";
const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
pub const ZERO_CODE: i32 = 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 state = State { counter: 0 };

    STATE.save(deps.storage, &state)?;
    Ok(Response::new().add_attribute("counter", ZERO_CODE.to_string()))
}

This is explicit for reading. I explain it step by step. We create the first entry point, and pass some parameters to instantiate:

deps - The dependencies, this contains your contract storage, the ability to query other contracts and balances, and some API functionality
env - The environment, contains information such as its address, block information such as current height and time, as well as some optional transaction info
info - Message metadata, contains the sender of the message (Addr).
msg - The InstantiateMsg you define in src/msg.rs

The dash _ prefix of params means we don't use it in function and the compiler will not show a warning notification.

Return of this function Result enum with Response struct from cosmwasm_std and enum ContractError. Then we set the contract name and contract version to storage with set_contract_version.

Now this is the main section of instantiate, we create an instance of struct State with a value counter equal to 0 and assign it to the state variable

STATE creates a new item in storage and saves state to storage.
Finally, we warp Response struct has attribute counter and its value is 0 by Ok.

Testing module

Alright, we have implemented the first entry point of our contract! Let's get to testing it!
So let's look at our src/contract.rs file, at the bottom, add the following code:

#[cfg(test)]
mod tests {
    use crate::msg::InstantiateMsg;
    use cosmwasm_std::attr;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};

    use super::{instantiate, ZERO_CODE};

    const ADDR1: &str = "addr1";

    // instantiate with provide admin address
    #[test]
    fn test_instantiate() {
        let mut deps = mock_dependencies();
        let env = mock_env();
        let info = mock_info(ADDR1, &[]);

        let msg = InstantiateMsg {};
        let resp = instantiate(deps.as_mut(), env, info, msg).unwrap();

        assert_eq!(
            resp.attributes,
            vec![attr("counter", ZERO_CODE.to_string())]
        )
    }
}

We create a module test and unit test function test_instantiate.
First, we need to import mock to simulate parameters (mock_dependencies, mock_env, mock_info) and import the instantiate function and ZERO_CODE constant from above via the super keyword.
asssert_eq! is marco in Rust to compare two values. In this case, we compare response from instantiate with array vector has an element attr("counter", ZERO_CODE.to_string())

Let's test the module. We have two ways:

Open the terminal and run cargo test:
Simply, press Run Test in VS Code:

If your output is like the below, everything is right:

running 1 test
test contract::tests::test_instantiate ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests cw-starter

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

It runs 1 test case, and 1 passed.

Sumary

We just created the first entry point of the smart contract is instantiate.
We also created a module testing function.

Thanks to everyone to read the post. Part 3 I introduce how to execute the smart contract. Have a good day!

Writing Smart contract with CosmWasm (Part 1)

Vu — Fri, 02 Sep 2022 16:59:31 +0000

Introduction

Hi, I am Vu, and I share a new series: Writing a smart contract with CosmWasm.

What are smart contracts?

It is a simple program stored on a blockchain. It can execute when predetermined conditions.
These are some of the benefits and props of the smart contract:

Security
Automation
Speed and efficiency
Trust and transparency

Of cause, it is a program by humans and they can make mistakes and this makes the contracts vulnerable to attacks.
Maybe, a smart contract cannot exceed 24kb or else it will run out of gas.

Environment

In part 1, I introduce the environment to develop and how to set up this.

Setup rust

Rust is the main programming language used for CosmWasm smart contracts. You can follow this to set up Rust.
Then run the following commands:

# 1. Set stable as the default release channel

rustup default stable 
cargo version

# update if it is lower than 1.50.0+

rustup update stable

# 2. Add WASM as the compilation target:

rustup target list --installed
rustup target add wasm32-unknow-unknown

# 3. Install the following packages to generate the contract:

cargo install cargo-generate --features vendored-openssl
cargo install cargo-run-script

Setup VS Code

VS Code is a powerful editor. You can download and install it on all platforms by link.
And you can add extensions: rust-analyzer to the diagnostic rust code.

And CosmWasm IDE to develop and deploy the smart contract.

After all, we finished to setup the environment to develop smart contract programming.

Time to start.

This is the time to write a smart contract. We will write a smart contract which has a logic: when we execute, the smart contract will increment the counter variable to one.

First of all, we are starting with the CW-Template to sets up a boilerplate project.
I use a version of minimal boilerplate:

cargo generate --git https://github.com/CosmWasm/cw-template.git --branch 1.0-minimal --name counter-contract

Once complete, we look output:

🔧   Destination: /Users/oraichain/Desktop/person/rust-lab/cw-starter ...
🔧   Generating template ...
[ 1/30]   Done: .cargo/config
[ 2/30]   Done: .cargo
[ 3/30]   Skipped: .circleci/config.yml
[ 4/30]   Done: .circleci
[ 5/30]   Done: .editorconfig
[ 6/30]   Done: .github/workflows/Basic.yml
[ 7/30]   Done: .github/workflows
[ 8/30]   Done: .github
[ 9/30]   Done: .gitignore
[10/30]   Done: Cargo.lock
[11/30]   Done: Cargo.toml
[12/30]   Done: LICENSE
[13/30]   Done: NOTICE
[14/30]   Done: README.md
[15/30]   Done: examples/schema.rs
[16/30]   Done: examples
[17/30]   Done: rustfmt.toml
[18/30]   Done: schema/count_response.json
[19/30]   Done: schema/execute_msg.json
[20/30]   Done: schema/instantiate_msg.json
[21/30]   Done: schema/query_msg.json
[22/30]   Done: schema/state.json
[23/30]   Done: schema
[24/30]   Done: src/contract.rs
[25/30]   Done: src/error.rs
[26/30]   Done: src/helpers.rs
[27/30]   Done: src/lib.rs
[28/30]   Done: src/msg.rs
[29/30]   Done: src/state.rs
[30/30]   Done: src
🔧   Moving generated files into: `/Users/oraichain/Desktop/person/rust-lab/cw-starter`...
💡   Initializing a fresh Git repository
✨   Done! New project created /Users/oraichain/Desktop/person/rust-lab/cw-starter

Let's open project with the commands:

cd cw-starter # change dir to project.
code . # open project with vscode.

Tada, you had a smart contract project.

Thank you read the post. I will update part 2 soon. Have a good day!

Moving from Vim to Helix

Vu — Mon, 01 Aug 2022 10:46:00 +0000

This is my article about Helix - a post-modern editor.

Reference:

Helix
Github

Built-in with Rust.

Yes, Helix is an open source written by Rust, no Electron, no Javascript. You can use it tmux, plain any terminal. My combo iTerm2 + tmux - very good :), save for battery life and still have a good performance.

The Begin.

If you use vim or neovim, you will have a little surprise with Helix. Helix follows the selection -> action model. This means that whatever you are going to act on: a word, a line, etc is selected first and after action on it (delete, yank, change, etc).

You still move with j, k, l, h as Vim. But when use w, b or e, you will see a cursor select your word.

Some cheatsheet:

Action	Helix	Vim
Delete a word	`wd`	`dw`
Delete a character	`d`	`x`
Select a line	`x`	`Shift + v`
Go to the first file	`gg`	`gg`
Go to end file	`ge`	`Shift + g`
Go to end line	`gl`	`$`
Go to first line	`gh`	`0`

And you can use shell command in helix:

More information: use tutor

Easy to config

If vim uses .vimrc to config for vim, helix uses config.toml to configure editor. This is official documents
It is easy to config, I show my current config.

theme = "gruvbox"

[editor]
line-number = "relative"
mouse = true

[editor.cursor-shape]
insert = "bar"
normal = "block"
select = "underline"

[editor.whitespace.render]
space = "none"
tab = "all"
newline = "none"

[editor.whitespace.characters]
space = "·"
tab = "╎"

Props and Cons

Props:
- Config with file
- LSP integration
- Fuzzy file in the project
- Debugging (experimental)
Cons:
- Not File explorer.
- Some LSP need a manual config (JSX, TSX).
- Not support plugin.
- Status-bar is simple.
- A lot of issues are pending.

Anyway, helix is developing, and we can hope many contributor help to improve.

My setup Mac for Backend Developer

Vu — Sat, 28 May 2022 02:10:11 +0000

Summary

I received a new machine from my company for my job. With a machine with no software, so let's start setups an environment on it. My machine is MacbookPro 16" 2019 with Intel Core i9 ( I know it is very hot), 1TB SSD and 16GB RAM. Why 2019? I have tools for DevOps, sometimes I have read a few complaints about the M1 process from other engineers, so I decided on a Macbook Pro 16" 2019

First of all, I installed homebrew - package management in OSX. Yes, many tools below use brew installed, I don't want you pkg files, instead of the use command line.

brew install wget

Apps

I am using...

Docker: build and deployment container
Terraform: build and deployment infrastructure
AWS CLI: interaction with aws via command line
Kubectl: for learning and deployment of Kubernetes
TablePlus: Database management
Raycast: Spotlight instead
Notion: quick note and share
Bitwarden: Password management
Postman: Testing my API
Sourcetree: Version Control Source UI
Flame shot: capture and edit image
Karabiner: I use an external keyboard and it helps remap key
Microsoft Edge: Primary browser, Safari is the second browser

Terminal and Editor

I love the command line. An interesting terminal brings much inspiration for a development job. This is currently my terminal and how to set up it:

I choice iTerm2 instead of the default terminal on OSX. iTerm2 has many colour schemes, is customised a little and uses GPU support rendering.
My shell is ZSH with Oh-my-zsh and Starship. Starship shows a whale in the terminal, it is very cool!.
BlexMono Nerd Font is my choice font.

As a Backend Developer, I choice Neovim, exact LunarVim is the primary editor for Go and NodeJS, sometimes I also write HCL, config file like YAML.
With LunarVim you have an editor like VSCode but faster, smaller and customizer than VSCode. I use Gruvbox scheme with Lunarvim

Aliases

To make your life easy, don't forget to use the aliases command.
Simply, add some command below to .zshrc, reload and enjoy!

alias k="kubectl" 
alias tf="terraform"
alias ggraph="git log --oneline --graph --color --all --decorate"
alias branch="git branch -a"
...

Exit

Thanks for reading. Have a good day!

My First React Template

Vu — Wed, 28 Oct 2020 06:09:24 +0000

Hi there,
I created template React with Typescript, some customize.
You can get it with command:

npx create-react-app name --template react-rematch-ts

I also have init some example file in project when you create.

Link: npm
Hope you enjoy it!