DEV Community: Roongroj Phetkheaw

uv cheatsheet 🦀🐍

Roongroj Phetkheaw — Sun, 19 Oct 2025 07:19:18 +0000

https://mathspp.com/blog/uv-cheatsheet

Deploy Token on SUI 🚀 (Move 2024 edition) and Tips and Trick.

Roongroj Phetkheaw — Mon, 13 May 2024 06:29:16 +0000

Move the 2024 edition onwards

Let’s start

Install SUI

brew

brew install sui

Cargo 🦀

cargo install --locked --git https://github.com/MystenLabs/sui.git --branch testnet sui

Run the following command to create your Sui account:

Set Up Sui on Devnet

Configure the Sui CLI to use the DevNet environment. This typically involves setting the network configuration to point to DevNet endpoints.

sui config set --network devnet

sui client new-address ed25519

You can check your active address via sui client active-address and switch to a new address via sui client switch --address [ADDRESS]

Obtain Sui Tokens from the Faucet
sui client faucet --address
You can check your balance via sui client gas which will output something like this:

Note: You’ll need to replace recipient with the address you generated above.

Verify Your Sui Address

sui keytool list

Create a New Move Package
sui move new my_first_package
Check Active Address
Make sure that your newly created Sui address is set as the active address in your Sui CLI configuration.

sui client active-address

module your_namespace::YourToken {
    use std::option;
    use sui::coin;
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

   // Name matches the module name, but in UPPERCASE
   // Internal struct declarations are not yet supported annotations are required on struct declarations from the Move 2024 edition onwards.
    public struct YourToken has key, store {}

    public fun initialize(ctx: &mut TxContext) {
        let (treasury, _metadata) = coin::create_currency<YourToken>(1000000, 6, b"YT", b"YourToken", b"Your token description", option::some(ctx.sender));
        transfer::public_freeze_object(metadata);
        // deploy and mint_and_transfer token
        coin::mint_and_transfer(&mut treasury, 1000000000000000000, tx_context::sender(ctx), ctx);
        transfer::public_transfer(treasury, tx_context::sender(ctx));
    }

    public entry fun mint(treasury: &mut coin::TreasuryCap<YourToken>, amount: u64, recipient: address) {
        coin::mint(treasury, amount, recipient);
    }

    public entry fun burn(treasury: &mut coin::TreasuryCap<SUPRA>, coin: coin::Coin<SUPRA>) {
        coin::burn(treasury, coin);
    }
}

For your token LOGO 😎

use sui::url
 const IconUrl: vector<u8> = b"your_ipfs_Url";

you can update the logo file
here:

nft.storage

Pinata | Crypto's file storage

Add IPFS file uploads and retrieval in minutes so you can focus on your app — because you’ve got better things to code than infrastructure.

alt="favicon"
class="c-embed__favicon m-0 mr-2 radius-0"
src="https://framerusercontent.com/images/xePsNxlJkbNDeEtG9QwvSr4Kcc.png"
loading="lazy" />
pinata.cloud

Update init token

    fun init(witness: YourToken, ctx: &mut TxContext) {
        let ascii_url = std::ascii::string(IconUrl);
        let icon_url = url::new_unsafe(ascii_url);
    // Declare 'treasury' as mutable
        let (mut treasury, metadata) = coin::create_currency(witness, 9, b"symbol_YourToken", b"YourToken", b"YourToken info", option::some(icon_url), ctx);

Check your move version or migrate new version

sui move migrate

UPDATING GIT DEPENDENCY
https://github.com/MystenLabs/sui.git
Package toml does not specify an edition. As of 2024, Move requires all packages to define a language edition.

Please select one of the following editions:

1) 2024.beta
2) legacy

Selection (default=1): 1

Would you like the Move compiler to migrate your code to Move 2024? (Y/n) y

Generated changes . . .
INCLUDING DEPENDENCY Sui
INCLUDING DEPENDENCY MoveStdlib
BUILDING firoll

No migration is required. Enjoy!
Recorded edition in 'Move.toml'
Let’s Deploy and Test!
sui client publish --gas-budget 10000000
or

sui client publish --gas-budget 100000000 --skip-dependency-verification

Interaction
Mint Token

sui client call --package --module firoll --function mint --args 1000000 --gas-budget 300000000
Burn token

sui client call --package --module supra --function burn --args --gas-budget 3000
Handling Updates and Migrations
To update your Move code or migrate to a newer version, use:

sui move migrate
more…..

Error

sui client ptb
--gas-budget 100000000
--assign sender @$MY_ADDRESS
--move-call $PACKAGE_ID::todo_list::new
--assign list
--transfer-objects "[list]" sender

[warn] Client/Server api version mismatch, client api version : 1.24.1, server api version : 1.25.0
thread '2024-05-06T03:14:23.341406Z ERROR telemetry_subscribers: panicked at crates/sui-protocol-config/src/lib.rs:1252:9:
Network protocol version is ProtocolVersion(44), but the maximum supported version by the binary is 43. Please upgrade the binary. panic.file="crates/sui-protocol-config/src/lib.rs" panic.line=1252 panic.column=9
main' panicked at crates/sui-protocol-config/src/lib.rs:1252:9:
Network protocol version is ProtocolVersion(44), but the maximum supported version by the binary is 43. Please upgrade the binary.
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace
Aborted
run this

cargo install --locked --force --git https://github.com/MystenLabs/sui.git --branch devnet sui

gas-budget error
verify

Tips and Trick
Using JSON Output for Better Scripting and Debugging
When deploying contracts or interacting with the Sui network, you can use the --json flag to format the output as JSON. This is particularly useful for developers who want to script interactions with the CLI and process the output programmatically.

sui client publish --package ./path_to_your_package --gas-budget 100000000 --json
Check Transaction Status
After submitting transactions, you can check their status to ensure they have been processed successfully. This is critical for operations where the state must be verified before proceeding.

sui client tx-status --digest
Efficiently Manage Gas and Fees
Understanding and managing gas is crucial. Use the --gas-budget parameter to specify the maximum amount of gas you're willing to spend on a transaction. This helps in avoiding unexpectedly high fees.

sui client call --package <PACKAGE_ID> --function <FUNCTION_NAME> --args <ARGS> --gas-budget 500000

Save Deployment Artifacts
When deploying contracts, the CLI tool can generate important artifacts such as logs or contract addresses, which are often useful for debugging or operational purposes.
Use appropriate flags to save these outputs to a specific directory or file.

sui client call --package <PACKAGE_ID> --module <MODULE_NAME> --function <FUNCTION_NAME> --args <ARGS> --

`
previewPlease Give Me a Star! ⭐ ⭐ ⭐
If you find this repository useful, please consider giving it a star on GitHub. Your support is a big thank you to me and motivates me to continue developing and sharing more great content!

Easy to install Python -> Mac | Fix $PATH

Roongroj Phetkheaw — Sat, 04 May 2024 18:36:01 +0000

1. Install homebrew

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2.Install Pyenv

brew install pyenv pyenv-virtualenv
pyenv install -l

3.Test pyenv

pyenv virtualenv 3.12.0 myproject

pyenv local myproject

pyenv virtualenv-delete my project

4.Test python

$ python3 --version
Python 3.9.6
$ which -a python3
/usr/bin/python3

==================================================
FIX Python not found in ZSH

Rus this

brew info python

Python has been installed as
  /opt/homebrew/bin/python3

Unversioned symlinks `python`, `python-config`, `pip` etc. pointing to
`python3`, `python3-config`, `pip3` etc., respectively, have been installed into
  /opt/homebrew/opt/python@3.11/libexec/bin

Open profile config

nano ~/.bash_profile

I use zsh and VS Code, so I ran this:

code ~/.zshrc

Add the following lines to the file:

export PATH="/opt/homebrew/opt/python@3.11/libexec/bin:$PATH"

Now reload the shell profile by running the following command:

source ~/.bash_profile

For zsh, you could use this:

source ~/.zshrc

useful ssh-keygen tips

Roongroj Phetkheaw — Sat, 20 Apr 2024 15:59:59 +0000

useful ssh-keygen tips

sshkeygen
generates a public key from a secret key
ssh-keygen -y -f ~/.ssh/id_rsa > ~/.ssh/id_rsa.pub
generates fingerprints from a public key
ssh-keygen -l -E md5 -f ~/.ssh/id_rsa.pub
changing passphrase
ssh-keygen -p -f ~/.ssh/ssh_key.pem

Solana: Note

Roongroj Phetkheaw — Fri, 29 Mar 2024 16:06:22 +0000

Accounts => Everything is an account!!!

Unique 256-bit address.
Hold some balance of SOL.
Can store arbitrary data.
Data Storage is paid with Rent.

Anyone can credit SOL or read data.

Only the account's owner can debit SOL or modify data.

{
   key: number,     // The address of the account
   lamports: number,      // Lamports currently held
   data: Uint8Array,     // Data stored in the account
   is_executale: boolean, // Is this data a program
   owner: PublicKe      // the program with write access
}

//Lamports: This is the unit of currency
in Solana (similar to “wei” in Ethereum).
Accounts hold lamports, which can be converted to SOL, Solana's native currency. 1 SOL is equal to 1,000,000,000 lamports it same as Satoshi on BTC. Data: This is a section where the account can store information.

Programs = Smart contracts

Smart contracts on Solana are called "programs"

Language written in Rust, C/C++, Python.
Data is eBPF bytecode (ebpf bite code which is the Berkeley packet filter bite code
Special kind of account
Programs are stateless: they read & write data to other accounts
This allows programs to be executed in parallel
Must be the owner of an account to modify
Programs process instructions
Programs can send instructions to other programs using called cross program invocation or CPI

{
     program_id: number, // program this instruction is for
     keys: Arry<{       // actions involved in the instraction
      key: PublicKey,
      is_mutable: boolean,
      is_signer: boolean,
     }>,
     data: Uint8Array, // action +args
}

Transactions

Transaction => RPC Client => Network

{
 message: {
    instructions: Array<Instraction>, // list of instructions
    recent_blockhash: number,   // de-duplication
    fee_payer: PublicKey,      // pays "gas" fee
    ...
},
 signers: Array<Uint8Array>, // signed version of trasaction
}

Transactions:
Transactions are the vehicles through which instructions are executed on the Solana blockchain. A transaction consists of multiple components:

Instructions: These are the individual actions that a transaction aims to perform. Each instruction specifies the program it's intended for, the accounts involved, and any additional data or arguments necessary for the program to execute the instruction.
Recent Blockhash: This is a hash value derived from a recent block on the blockchain. It serves as a de-duplication mechanism, ensuring that transactions are not replayed or executed multiple times.
Fee Payer: Every transaction requires a fee to be paid in SOL, which compensates the validators for processing the transaction. The fee payer is the account responsible for paying this fee.
Signers: To authorize the execution of a transaction, it must be signed by one or more accounts. The signers array contains the cryptographic signatures of these accounts, proving their consent to the transaction.
Transactions are submitted to the Solana network through an RPC (Remote Procedure Call) client, which broadcasts the transaction to the validators responsible for processing and adding it to the blockchain.

+-------------+
|   Client    | 
|  (dApp UI)  |
+-------------+
     |
     | User Action
     | Triggers Transaction
     v
+-------------+
|  RPC Client |
+-------------+
     |
     | Routes Transaction
     v
+-------------+
|  Validator  |
+-------------+
     |
     | Executes Instruction
     v
+-------------+
|   Program   |
| (Smart      |
|  Contract)  |
+-------------+
     |
     | Modifies State
     v
+-------------+
|  Counter    |
|  Account    |
|  count = 1  |
+-------------+

Solana: From Zero to Noob - A Journey Through the Rust Wilderness 🤓

Roongroj Phetkheaw — Fri, 29 Mar 2024 11:33:00 +0000

SAWADEE Rrap (Hello), fellow crypto enthusiasts! If you're reading this, chances are you've stumbled upon the exciting world of Solana, the high-performance blockchain that promises to revolutionize the way we think about decentralized applications. But before we dive into the nitty-gritty of this cutting-edge technology, let's address the elephant in the room – Rust.

Ah, Rust – the programming language that strikes fear into the hearts of even the most seasoned developers. With its steep learning curve and unforgiving syntax, it can feel like you're scaling a treacherous mountain without a rope. But fear not, my friends! For those willing to embrace the challenge, the rewards are immense.

Rust is the backbone of Solana's architecture, and mastering it is the key to unlocking the full potential of this blockchain behemoth. It's a language that demands precision, patience, and a willingness to embrace the mind-bending concepts of memory management and ownership rules. But once you've conquered these hurdles, you'll find yourself in possession of a powerful tool that can create lightning-fast, secure, and concurrent applications.

Now, I know what you're thinking: "Lane, why can't we just stick to the tried-and-true languages we already know?" Well, my dear fellow, that's a valid question. But the truth is, Solana's ambitious goals – scalability, speed, and security – necessitate a language that can handle the demands of high-performance computing. And Rust, with its low-level control and zero-cost abstractions, is the perfect candidate for the job.

But fear not, my friends! While the path to Rust mastery may seem daunting, there are countless resources available to guide you through the wilderness. From online courses and tutorials to vibrant community forums, you'll find a wealth of knowledge at your fingertips. And let's not forget the countless developers who have already braved the Rust journey and emerged victorious, ready to share their hard-earned wisdom with those willing to listen.

So, my fellow noobs, embrace the challenge! Dive headfirst into the world of Rust and Solana, for the rewards are truly worth the effort. Remember, Rome wasn't built in a day, and neither will your Solana skills be mastered overnight. But with perseverance, dedication, and a healthy dose of humor, you'll soon find yourself wielding the power of Rust like a true blockchain warrior.

And who knows? Perhaps one day, you'll be the one writing the "Solana: From Zero to Hero" guide, inspiring the next generation of developers to embark on this exciting journey. Until then, keep coding, keep learning, and never forget – the path to greatness is paved with countless compiler errors and head-scratching moments. Embrace them, my friends, for they are the badges of honor that mark your progress in the Rust wilderness.

Find memory address in Rust

Roongroj Phetkheaw — Wed, 27 Mar 2024 17:30:51 +0000

This code demonstrates a few concepts: variable declaration, value printing, converting a numeric value to its byte representation, iteration with enumeration, and printing memory addresses.

fn main() {
    // convert and find address
    let x: u32 = 32;
    println!("The Value of x is:{}",x);

    // Convert x to bytes and print each byte
    let bytes = x.to_ne_bytes(); // Covert to native endian bytes order
    for (i, byte) in bytes.iter().enumerate(){
        println!("Byte {} of x: {:08b}", i , byte);

    }

    println!("The address of x is: {:p}" ,&x);
    println!("The address of x is: {:p}", &x as *const u32);
    println!("The address of x is: {:p}", &x as *const _);

}

Converting to Bytes and Iteration:

let bytes = x.to_ne_bytes(); // Convert to native endian bytes order

The to_ne_bytes method converts the integer x into an array of bytes in the native endian order of the machine (either little or big endian, depending on the architecture).

for (i, byte) in bytes.iter().enumerate(){
    println!("Byte {} of x: {:08b}", i , byte);
}

This loop iterates over the byte array. The enumerate method adds a counter (i), and for each byte in bytes, it prints the byte's index and its binary representation (:08b formats the byte as an 8-bit binary number).

Printing Memory Addresses:

println!("The address of x is: {:p}" ,&x);

This prints the memory address of x. The :p formatter is used for pointer types, and &x takes the address of x.

println!("The address of x is: {:p}", &x as *const u32);

This is similar to the previous line but explicitly casts the reference &x to a constant pointer type *const u32.

println!("The address of x is: {:p}", &x as *const _);

This line also prints the address of x, but uses type inference (_) for the pointer type. It's essentially saying "treat &x as a constant pointer to some type, but I don't care to specify what that type is."

The result:

The Value of x is:32
Byte 0 of x: 00100000
Byte 1 of x: 00000000
Byte 2 of x: 00000000
Byte 3 of x: 00000000
The address of x is: 0x16db4e474
The address of x is: 0x16db4e474
The address of x is: 0x16db4e474

Journey Beyond the Basics: A Year with Rust and the Quest to Code Confidently

Roongroj Phetkheaw — Sun, 24 Mar 2024 19:59:57 +0000