မင်္ဂလာပါ၊ 100 Days of Blockchain Series ကနေ ကြိုဆိုပါတယ်။ ဒီနေ့ (Day 9) မှာတော့ Blockchainလောကမှာ အသုံးအများဆုံး Standard တစ်ခုဖြစ်တဲ့ ERC-20 Token Standard အကြောင်းကို လေ့လာပြီး Remix IDE ကိုသုံးကာ ကိုယ်ပိုင် Token တစ်ခု လက်တွေ့ ဖန်တီးကြည့်ကြပါမယ်။

ERC-20 ဆိုတာ ဘာလဲ? ကျွန်တော်တို့ CoinMarketCap လို နေရာတွေမှာ တွေ့နေရတဲ့ Crypto Coin တွေ အများကြီးထဲမှာ Ethereum Blockchain ပေါ်မှာ Run တဲ့ Token အများစုဟာ ERC-20 Standard ကို အသုံးပြုထားတာ ဖြစ်ပါတယ်။

• EIP vs ERC: Ethereum မှာ အသစ်တစ်ခုခု လုပ်ချင်ရင် အရင်ဆုံး Proposal တင်ရပါတယ် (EIP — Ethereum Improvement Proposal)။ အဲ့ဒီ Proposal ကို အတည်ပြုပြီး Standard တစ်ခုအနေနဲ့ သတ်မှတ်လိုက်တဲ့အခါ ERC (Ethereum Request for Comment) ဖြစ်လာပါတယ်။ ERC-20 ဆိုတာကတော့ Token တွေအတွက် သတ်မှတ်ထားတဲ့ စံနှုန်း (Standard) တစ်ခုပါ။

ERC-20 Token တစ်ခုရဲ့ အဓိက အစိတ်အပိုင်းများ Token တစ်ခု တည်ဆောက်မယ်ဆိုရင် အဓိက ပါဝင်ရမယ့် အချက် (၄) ချက်ရှိပါတယ်။

1. Name: Token ရဲ့ နာမည် (ဥပမာ — Ethereum)
2. Symbol: အတိုကောက် Ticker (ဥပမာ — ETH, USDT)
3. Decimals: ဒါက နည်းနည်း စိတ်ဝင်စားဖို့ ကောင်းပါတယ်။ Solidity Language မှာ ဒသမကိန်း (Floating points) တွေကို Support မလုပ်ပါဘူး။ ဒါကြောင့် တိကျမှုရှိအောင် 18 Decimals ကို Standard အနေနဲ့ သုံးကြပါတယ်။ (1 Token = 10¹⁸ Wei)။ USDT လို Coin တွေမှာတော့ 6 Decimals သုံးတာမျိုး ရှိပါတယ်။
4. Total Supply: စုစုပေါင်း ထုတ်လုပ်မယ့် ပမာဏ။

လက်တွေ့ ရေးသားစမ်းသပ်ခြင်း (Practical Lab)

ဒီနေ့မှာတော့ Developer တွေ အသုံးများတဲ့ Remix IDE ကို အသုံးပြုပြီး GofarToken ဆိုတဲ့ ကိုယ်ပိုင် Token လေးတစ်ခု ဖန်တီးကြည့်ပါမယ်။

Step 1: Setup Environment

• Browser မှာ remix.ethereum.org ကို သွားပါ။

• GopherToken.sol ဆိုပြီး ဖိုင်အသစ်တစ်ခု ဆောက်ပါ။

Step 2: Coding ERC-20 Standard ကို ကိုယ်တိုင် အစကနေ လိုက်ရေးနေစရာ မလိုပါဘူး။ လုံခြုံရေးအရ စိတ်ချရတဲ့ OpenZeppelin Library ကို Import လုပ်ပြီး သုံးပါမယ်။

Solidity

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract GofarToken is ERC20 {
    constructor() ERC20("GofarToken", "GFT") {
        _mint(msg.sender, 10000 * 10 ** decimals());
    }
}

Step 3: Compile & Deploy

• Solidity Compiler Tab မှာ Compile လုပ်ပါ။ (အစိမ်းရောင် အမှန်ခြစ်ပြရင် အဆင်ပြေပါပြီ)။
• Deploy Tab ကိုသွားပါ။ Environment မှာ Injected Provider — MetaMask ကို ရွေးပါ။ (Testnet တစ်ခုခုမှာ ETH ရှိဖို့ လိုပါတယ်)။
• Deploy ခလုတ်ကို နှိပ်ပြီး MetaMask မှာ Transaction Confirm လုပ်ပါ။

Step 4: Verify on Wallet Deploy လုပ်ပြီးသွားရင် ရလာတဲ့ Contract Address ကို Copy ကူးပြီး MetaMask မှာ “Import Tokens” ကနေတဆင့် ထည့်သွင်းလိုက်ရင် ကိုယ့် Wallet ထဲမှာ ကိုယ်ဖန်တီးလိုက်တဲ့ Token တွေကို မြင်တွေ့ရမှာ ဖြစ်ပါတယ်။

နိဂုံး ဒီနေ့မှာတော့ ERC-20 သဘောတရားနဲ့ ကိုယ်ပိုင် Token တစ်ခု ဘယ်လိုထုတ်လုပ်လဲဆိုတာ လေ့လာခဲ့ပြီး ဖြစ်ပါတယ်။ နောက်ရက်တွေမှာတော့ NFT (ERC-721) အကြောင်းတွေကို ဆက်လက် မျှဝေပေးသွားပါမယ်။

အပြည့်အစုံသိချင်ရင် Youtube Video ဝင်ကြည့်လို့ရပါတယ်ဗျ။

https://youtu.be/ALiRnGSWI58

မင်္ဂလာပါ၊ 100 Days of Blockchain Series ရဲ့ Day 8ကနေ ကြိုဆိုပါတယ်။ ဒီနေ့မှာတော့ ကျွန်တော်တို့ Blockchain ပေါ်မှာ ကိုယ်လုပ်ဆောင်လိုက်တဲ့ Transaction တွေ၊ သူများရဲ့ Wallet တွေကို ဘယ်လို စောင့်ကြည့်လေ့လာမလဲဆိုတာကို ပြောပြသွားမှာ ဖြစ်ပါတယ်။ ဒီအတွက် ကျွန်တော်တို့ အသုံးပြုမယ့် Tool ကတော့ Block Explorer (ဥပမာ — Etherscan) ဖြစ်ပါတယ်။

https://etherscan.io

Block Explorer ဆိုတာ ဘာလဲ?

Block Explorer ဆိုတာ Blockchain တစ်ခုလုံးရဲ့ ဒေတာတွေကို ကြည့်ရှုနိုင်တဲ့ Web Interface တစ်ခုဖြစ်ပါတယ်။ Ethereum အတွက်ဆိုရင် Etherscan၊ Binance Smart Chain အတွက်ဆိုရင် BscScan၊ Polygon အတွက်ဆိုရင် PolygonScan စသဖြင့် သက်ဆိုင်ရာ Chain အလိုက် Explorer တွေ ရှိကြပါတယ်။ ဒီ Explorer တွေကနေတဆင့် Block တွေ၊ Transaction တွေ၊ Wallet Address တွေရဲ့ အချက်အလက်တွေကို အလွယ်တကူ ဝင်ရောက်ကြည့်ရှုနိုင်ပါတယ်။

Mainnet vs. Testnet

Etherscan သုံးတဲ့အခါ သတိပြုရမှာက ကိုယ်သုံးနေတဲ့ Network ကို ရွေးချယ်ဖို့ပါပဲ။ ကျွန်တော်တို့က လောလောဆယ် စမ်းသပ်လေ့လာနေတဲ့ အဆင့်ဖြစ်တဲ့အတွက် “Sepolia Testnet” ကို အသုံးပြုနေတာ ဖြစ်လို့ Sepolia Etherscan မှာ သွားကြည့်မှသာ ကိုယ့်ရဲ့ Transaction တွေကို တွေ့ရမှာ ဖြစ်ပါတယ်။ Mainnet မှာ သွားရှာရင် တွေ့မှာ မဟုတ်ပါဘူး။

Transaction တစ်ခုကို ဘယ်လို ဖတ်မလဲ?

ကျွန်တော်တို့ Wallet ကနေ ပိုက်ဆံလွှဲလိုက်တဲ့အခါ Transaction Hash (Tx Hash) ဆိုတဲ့ ID တစ်ခု ထွက်လာပါတယ်။ အဲ့ဒီ Hash ကို Etherscan မှာ ရှာလိုက်ရင် အောက်ပါ အချက်အလက်တွေကို တွေ့ရပါမယ် -

1. Status: ဒီ Transaction က အောင်မြင်လား (Success)၊ စောင့်နေရတုန်းလား (Pending)၊ ဒါမှမဟုတ် ကျရှုံးသွားလား (Fail) ဆိုတာကို ပြပေးပါတယ်။ တခါတလေ “Indexing” ဆိုပြီး ပြနေရင်တော့ Node တွေက ဒေတာကို စီစဉ်နေတဲ့ အချိန်မို့လို့ ခဏစောင့်ရင် Success ဖြစ်သွားပါလိမ့်မယ်။
2. From / To: ဘယ်သူ့ဆီကနေ (From) ဘယ်သူ့ဆီကို (To) ပို့လိုက်တာလဲ ဆိုတာကို တွေ့ရပါမယ်။
3. Value: ETH ဘယ်လောက် ပို့လိုက်တာလဲ ဆိုတဲ့ ပမာဏပါ။
4. Transaction Fee: ဒီအလွှဲအပြောင်းအတွက် ကုန်ကျသွားတဲ့ အမှန်တကယ် Gas Fee ပမာဏပါ။ ဒါကို တွက်ချက်ရာမှာ Gas Price နဲ့ Gas Used ကို မြှောက်ပြီး တွက်ပါတယ်။

Wallet Address တစ်ခုကို လေ့လာခြင်း

Transaction တွေအပြင် Wallet Address တစ်ခုချင်းစီကိုလည်း ဝင်ကြည့်လို့ ရပါတယ်။ Address တစ်ခုကို ရှာလိုက်ရင် -

• Balance: လက်ရှိ ကျန်ရှိနေတဲ့ ETH ပမာဏ။
• Transaction History: ဒီ Wallet က လုပ်ခဲ့ဖူးတဲ့ အရောင်းအဝယ် မှတ်တမ်းအားလုံးကို တွေ့နိုင်ပါတယ်။
• Contract vs EOA: သာမန်လူတွေသုံးတဲ့ Wallet (Externally Owned Account) နဲ့ Code တွေရေးထားတဲ့ Smart Contract Address ကိုလည်း ခွဲခြားသိနိုင်ပါတယ်။ Contract ဆိုရင် “Contract” ဆိုတဲ့ Tab လေး အပိုပါလာတာကို တွေ့ရပါလိမ့်မယ်။

နိဂုံး

Etherscan ကို အသုံးပြုတတ်ခြင်းအားဖြင့် ကိုယ့်ရဲ့ Transaction တွေ ဘာဖြစ်နေလဲဆိုတာကို Wallet UI တစ်ခုတည်းကို အားမကိုးဘဲ ကိုယ်တိုင် အသေးစိတ် စစ်ဆေးနိုင်မှာ ဖြစ်ပါတယ်။ ဒါဟာ Blockchain ရဲ့ ပွင့်လင်းမြင်သာမှု (Transparency) ကို လက်တွေ့ အသုံးချခြင်းပါပဲ။

နောက်ရက်တွေမှာတော့ Token တွေ၊ Programming နဲ့ ပတ်သက်တဲ့ အကြောင်းအရာတွေကို ဆက်လက် လေ့လာသွားကြပါမယ်။

Facebook : web.facebook.com/letsfxckingo

Youtube : youtube.com/@lynnthelight

မင်္ဂလာပါ၊ 100 Days of Blockchain Series ရဲ့ Day 7 ကနေ ကြိုဆိုပါတယ်။ ဒီနေ့မှာတော့ Blockchain အသုံးပြုသူတိုင်း မဖြစ်မနေ ကြုံတွေ့ရမယ့်၊ တခါတလေ စိတ်ညစ်စရာကောင်းတဲ့ “Transaction Pending” ဖြစ်တဲ့ ပြဿနာရဲ့ နောက်ကွယ်က တရားခံတွေဖြစ်တဲ့ Mempool နဲ့ Gas Fee အကြောင်းကို ဆွေးနွေးသွားမှာ ဖြစ်ပါတယ်။

Mempool (Memory Pool) ဆိုတာ ဘာလဲ?

Mempool ဆိုတာကတော့ Transaction တွေ အတည်ပြုချက် (Confirmation) မရခင် ခေတ္တခဏ စောင့်ဆိုင်းရတဲ့ နေရာတစ်ခုပါ။ “Memory Pool” လို့ အရှည်ကောက်ခေါ်ပြီး Blockchain ရဲ့ “Waiting Room” (နားနေဆောင်) လို့လည်း တင်စားလို့ ရပါတယ်။

Transaction တစ်ခု လုပ်လိုက်တိုင်း Block ထဲကို တန်းမရောက်သွားပါဘူး။ Miner (သို့မဟုတ်) Validator တွေက မရွေးချယ်ခင် စောင့်ဆိုင်းရတဲ့ ဒီ Mempool ထဲကို အရင်ရောက်ပါတယ်။

အောင်မင်္ဂလာ အဝေးပြေးဝင်း ဥပမာ

ဒီသဘောတရားကို ရှင်းရှင်းလင်းလင်း မြင်သာဖို့အတွက် Blockchain Network တစ်ခုလုံးကို “အဝေးပြေး ကားဂိတ်” တစ်ခုလို့ မြင်ကြည့်ရအောင်။

• ခရီးသည်များ (Passengers) = Transactions: ကျွန်တော်တို့ ပို့လိုက်တဲ့ ပိုက်ဆံလွှဲခြင်း၊ NFT ဝယ်ခြင်း စတာတွေပါ။
• ဘတ်စ်ကား (Bus) = Block: ကားတစ်စီးမှာ လူ ၅၀ ပဲ ဆံ့သလို၊ Block တစ်ခုမှာလည်း Transaction အကန့်အသတ်ပဲ ဝင်လို့ရပါတယ်။
• ကားလက်မှတ်ခ = Gas Fee: ကားစီးဖို့ ပေးရတဲ့ စရိတ်ပါ။
• ကားဂိတ် (Waiting Room) = Mempool: ကားမထွက်ခင် ခရီးသည်တွေ စုပုံနေတဲ့နေရာပါ။

ပြဿနာက ဒီမှာ စပါတယ်။ ကားတစ်စီး (Block) က လူ ၅၀ ပဲ တင်လို့ရတယ်။ ဒါပေမဲ့ ဂိတ် (Mempool) မှာ ခရီးသည် ၅၀၀ လောက် စောင့်နေတယ်ဆိုပါစို့။ ကားဆရာ (Miner) က ဘယ်သူ့ကို အရင်တင်မလဲ?

အဖြေကတော့ “လက်မှတ်ခ (Gas Fee) အများဆုံး ပေးနိုင်တဲ့လူ” ကို အရင်တင်မှာ ဖြစ်ပါတယ်။

Gas Fee ဆိုတာ ဘာလဲ?

Gas Fee ဆိုတာ Blockchain ပေါ်မှာ ကိုယ့်ရဲ့ Transaction ကို ဆောင်ရွက်ပေးဖို့အတွက် ပေးရတဲ့ ဝန်ဆောင်ခ ဖြစ်ပါတယ်။ ဒါကို တွက်ချက်ပုံကတော့ -

Gas Fee = Gas Used (ကုန်ကျမယ့်ပမာဏ) x Gas Price (တစ်ယူနစ်ဈေးနှုန်း)

Network ကြပ်တဲ့အချိန် (လူသုံးများတဲ့အချိန်) ဆိုရင် Gas Price တွေ တက်လာတတ်ပါတယ်။ အဲ့ဒီအချိန်မှာ ကိုယ်က Gas Fee နည်းနည်းပဲ ပေးမယ် (Low Gas) ဆိုရင် Miner တွေက ကိုယ့်ကို မရွေးချယ်ဘဲ ထားခဲ့ကြပါလိမ့်မယ်။ ဒါကြောင့် ကိုယ့်ရဲ့ Transaction က Mempool ထဲမှာပဲ အကြာကြီး “Pending” ဖြစ်ပြီး သောင်တင်နေရတာ ဖြစ်ပါတယ်။

Metamask မှာ လက်တွေ့ စမ်းသပ်ကြည့်ခြင်း

လက်တွေ့မှာလည်း Metamask Wallet ကိုသုံးပြီး စမ်းသပ်ကြည့်လို့ ရပါတယ်။

1. Transaction တစ်ခုပို့တဲ့အခါ “Market” rate အတိုင်းထားရင် ပုံမှန်ကြာချိန်နဲ့ အဆင်ပြေပါတယ်။
2. ဒါပေမဲ့ “Low” ကို ရွေးပြီး Gas Fee လျှော့လိုက်မယ်ဆိုရင် Transaction က Pending ဖြစ်သွားပြီး အကြာကြီး စောင့်ရတတ်ပါတယ်။
3. အရမ်းမြန်မြန် လိုချင်တယ်ဆိုရင်တော့ “Aggressive” သို့မဟုတ် Gas Fee ပိုပေးလိုက်ရင် တစ်ခြားလူတွေထက် အရင်အတည်ပြုချက် ရရှိမှာ ဖြစ်ပါတယ်။

နိဂုံးချုပ်

ဒါကြောင့် နောက်တစ်ခါ ကိုယ့်ရဲ့ Transaction က Pending ဖြစ်နေပြီဆိုရင် “Blockchain ပျက်နေတာလား” လို့ မပူပါနဲ့။ ကိုယ်ပေးလိုက်တဲ့ “ကားခ” (Gas Fee) နည်းနေလို့ ကားဆရာက မတင်ဘဲ ထားခဲ့တာ ဖြစ်နိုင်ပါတယ်။ ဒီလိုအခြေအနေမျိုးမှာ Wallet ထဲကနေ “Speed Up” နှိပ်ပြီး Gas Fee ထပ်တိုးပေးလိုက်ရင် အဆင်ပြေသွားပါလိမ့်မယ်။

နောက်ရက်တွေမှာလည်း Blockchain နဲ့ ပတ်သက်တဲ့ စိတ်ဝင်စားစရာတွေကို ဆက်လက် မျှဝေပေးသွားပါမယ်။

Facebook : https://www.facebook.com/letsfxckingo

Youtube : https://www.youtube.com/@lynnthelight

၁။ Transaction တစ်ခု ဘယ်လို အလုပ်လုပ်သလဲ?

ကျွန်တော်တို့ Wallet တစ်ခုကနေ နောက်တစ်ခုကို ပိုက်ဆံ (ETH) လွှဲလိုက်တာဟာ Transaction တစ်ခုပါပဲ။ ဒါပေမဲ့ ဒီရိုးရှင်းတဲ့ လုပ်ဆောင်မှုရဲ့ နောက်ကွယ်မှာ Blockchain ပေါ်မှာ ဘာတွေဖြစ်သွားလဲဆိုတာ သိဖို့လိုပါတယ်။

ကျွန်တော့်ရဲ့ MetaMask Wallet မှာ Account သုံးခု (Account 1, 2, 3) ရှိတယ်ဆိုပါစို့။ Account 3 မှာ Balance က Zero ဖြစ်နေတယ်။ ဒါကို ပြောင်းလဲဖို့ မနေ့က သင်ခဲ့တဲ့အတိုင်း Google Web3 Faucet ကနေ Account 3 အတွက် 0.05 Sepolia ETH ကို Claim လိုက်ပါတယ်။ ဒါဟာ ပထမဆုံး Transaction ပါ။

Transaction တစ်ခု အောင်မြင်သွားပြီဆိုတာနဲ့ ကျွန်တော်တို့ Transaction Hash (Tx Hash) ဆိုတာ ရပါတယ်။ ဒါဟာ Transaction တစ်ခုချင်းစီရဲ့ ID ကတ်ပြားလိုပါပဲ။ ဒီ Hash ကိုသုံးပြီး ဘယ်သူက ဘယ်သူ့ဆီ ဘယ်လောက်လွှဲလိုက်တယ်၊ ဘယ်အချိန်မှာ လွှဲလိုက်တယ်ဆိုတဲ့ အချက်အလက် အသေးစိတ်ကို ပြန်ရှာလို့ရပါတယ်။

၂။ Etherscan (Block Explorer) ကို အသုံးပြုခြင်း

Blockchain ပေါ်မှာ ဖြစ်ပျက်နေသမျှ Transaction တွေကို ကြည့်ရှုစစ်ဆေးနိုင်တဲ့ Website တွေကို Block Explorer လို့ခေါ်ပါတယ်။ Ethereum အတွက်ဆိုရင်တော့ လူသိအများဆုံးက Etherscan ဖြစ်ပါတယ်။

Testnet အတွက် သီးသန့် Explorer တွေရှိပါတယ်။ ကျွန်တော်တို့သုံးနေတာက Sepolia Testnet ဖြစ်တဲ့အတွက် Sepolia Etherscan (https://sepolia.etherscan.io) ကို သုံးရပါမယ်။

Etherscan မှာ ဘာတွေကြည့်လို့ရလဲ?

• Search by Address: ကိုယ့် Wallet Address ကို ထည့်ရှာလိုက်ရင် ကိုယ့်ဆီဝင်လာတဲ့၊ ကိုယ်က လွှဲလိုက်တဲ့ Transaction History တွေ၊ လက်ကျန် Balance တွေကို မြင်ရပါမယ်။
• Search by Tx Hash: ခုနကပြောခဲ့တဲ့ Transaction ID ကို ထည့်ရှာရင် အဲဒီလွှဲပြောင်းမှုရဲ့ အခြေအနေ (Success/Pending/Fail)၊ Gas fee ဘယ်လောက်ကျလဲ၊ ဘယ် Block ထဲမှာ ပါသွားလဲဆိုတာ အတိအကျ ကြည့်လို့ရပါတယ်။

၃။ Transaction လက်တွေ့ စမ်းသပ်ခြင်း

လက်တွေ့အနေနဲ့ ကျွန်တော့်ရဲ့ Account 3 (0.05 ETH ရှိသူ) ဆီကနေ Account 1 ဆီကို 0.04 ETH ပြန်လွှဲကြည့်ပါမယ်။

1. MetaMask ကိုဖွင့်ပါ: Account 3 ကိုရွေးပြီး “Send” ကိုနှိပ်ပါ။
2. Recipient Address: Account 1 ရဲ့ Address ကို ထည့်ပါ။
3. Amount: 0.04 ETH လို့ ရိုက်ထည့်ပါ။
4. Confirm: Gas fee တွေကို စစ်ဆေးပြီး Confirm လုပ်ပါ။

ခဏစောင့်လိုက်ရင် Transaction အောင်မြင်ကြောင်း “Confirmed” ဆိုပြီး ပေါ်လာပါမယ်။ Etherscan မှာ သွားပြန်စစ်ကြည့်ရင် Status မှာ “Success” လို့ ပြနေပြီး၊ “From” မှာ Account 3 ၊ “To” မှာ Account 1 ကို တွေ့ရပါမယ်။

၄။ Block တွေနဲ့ Data Storage

Etherscan မှာ Transaction အသေးစိတ်ကို ကြည့်ရင် Block Number ဆိုတာကို တွေ့ရပါမယ် (ဥပမာ — Block #9887266)။

Blockchain ဆိုတာ Block တွေကို ကွင်းဆက်သဘော ချိတ်ဆက်ထားတာပါ။ Transaction တွေ များလာတာနဲ့အမျှ Block တွေ တစ်ခုပြီးတစ်ခု ပြည့်သွားပြီး နောက်ထပ် Block အသစ်တွေ ထပ်ပေါ်လာပါတယ်။ ဒါကြောင့် ကိုယ့်ရဲ့ Transaction က ဘယ် Block နံပါတ်မှာ သိမ်းဆည်းထားလဲဆိုတာကို ဒီနေရာမှာ တွေ့နိုင်တာ ဖြစ်ပါတယ်။

နိဂုံး

ဒီနေ့မှာတော့ Transaction တစ်ခုကို လက်တွေ့ စမ်းသပ်လွှဲပြောင်းခဲ့သလို၊ Etherscan လိုမျိုး Block Explorer တွေကိုသုံးပြီး ကိုယ့်ရဲ့ Transaction အချက်အလက်တွေကို ဘယ်လို စစ်ဆေးရမလဲဆိုတာ သိရှိသွားပြီ ဖြစ်ပါတယ်။ ဒီအခြေခံသဘောတရားတွေက Blockchain Developer တစ်ယောက်အတွက် မရှိမဖြစ် လိုအပ်ပါတယ်။

အားလုံးပဲ ကျေးဇူးတင်ပါတယ်။ Day 7 မှာ ပြန်တွေ့ကြမယ်နော်။

Youtube : https://youtu.be/eW3Ph47N1Sg?si=FSn9jvDR-P7praJy

Facebook : https://www.facebook.com/letsfxckingo

မင်္ဂလာပါ၊ 100 Days of Blockchain ရဲ့ Day 5 ကနေ ကြိုဆိုပါတယ်။ ဒီနေ့မှာတော့ Blockchain Developer တစ်ယောက်အနေနဲ့ မဖြစ်မနေ သိထားရမယ့် Testnet (စမ်းသပ်ကွန်ရက်) နဲ့ Faucet (စမ်းသပ်ငွေ ထုတ်ယူရာနေရာ) အကြောင်းကို ပြောပြပေးသွားမှာ ဖြစ်ပါတယ်။

Mainnet နဲ့ Testnet ဘာကွာလဲ?

Blockchain တစ်ခုမှာ Environment (၂) ခု ရှိလေ့ရှိပါတယ်။

1. Mainnet (Main Network): ဒါကတော့ တကယ့် Production အဆင့်ပါ။ ဒီပေါ်မှာ အသုံးပြုတဲ့ Coin/Token တွေက တကယ့်တန်ဖိုး (Real Value) ရှိပါတယ်။ ဥပမာ — Ethereum Mainnet ပေါ်မှာ Transaction လုပ်ချင်ရင် တကယ့်ပိုက်ဆံနဲ့ ဝယ်ထားတဲ့ ETH ကို Gas Fee အနေနဲ့ ပေးရပါတယ်။
2. Testnet (Test Network): ဒါကတော့ Developer တွေအတွက် ရည်ရွယ်ပါတယ်။ Mainnet ပေါ်မတင်ခင် စမ်းသပ်ဖို့ သုံးတာဖြစ်တဲ့အတွက် ဒီပေါ်မှာသုံးတဲ့ ETH တွေက တန်ဖိုးမရှိပါဘူး (No Value)။ ဂိမ်းထဲက ပိုက်ဆံလိုပါပဲ။

အခုလက်ရှိ Ethereum အတွက် အသုံးအများဆုံး Testnet ကတော့ Sepolia Testnet ဖြစ်ပါတယ်။

Faucet ဆိုတာဘာလဲ?

Mainnet မှာ ETH လိုချင်ရင် Exchange (Binance, Coinbase) တွေကနေ ပိုက်ဆံနဲ့ ဝယ်ရပါတယ်။ ဒါပေမယ့် Testnet ETH က တန်ဖိုးမရှိတဲ့အတွက် ဝယ်လို့မရပါဘူး။ အဲဒီအစား Faucet လို့ခေါ်တဲ့ နေရာတွေကနေ အလကား “Claim” (တောင်းယူ) ရပါတယ်။

Faucet ဆိုတာ Developer တွေကို စမ်းသပ်ဖို့အတွက် Token အလကားပေးတဲ့ ဝန်ဆောင်မှုတစ်ခုပါပဲ။

လက်တွေ့စမ်းသပ်ကြည့်ရအောင် (Step-by-Step Guide)

ဒီနေ့ Tutorial မှာတော့ Google Cloud Web3 Faucet ကိုသုံးပြီး Sepolia ETH တောင်းပုံကို လုပ်ပြပေးသွားပါမယ်။

Step 1: MetaMask မှာ Testnet ကိုဖော်ပါ

MetaMask မှာ ပုံမှန်ဆိုရင် Mainnet ကိုပဲ ပြထားတတ်ပါတယ်။ Sepolia ကိုမြင်ရဖို့အတွက် Settings ထဲက Network နေရာမှာ “Show test networks” ကို On ထားပေးဖို့ လိုပါတယ်။

Step 2: Google Web3 Faucet သို့သွားပါ

Google မှာ “Google Web3 Faucet” လို့ရိုက်ရှာလိုက်ပါ။ ပြီးရင် Network နေရာမှာ “Ethereum Sepolia” ကို ရွေးပါ။

https://cloud.google.com/application/web3/faucet/ethereum/sepolia

Step 3: Wallet Address ထည့်ပါ

ကိုယ့်ရဲ့ MetaMask က Wallet Address ကို Copy ကူးပြီး Faucet ဝက်ဘ်ဆိုက်မှာ Paste လုပ်ပါ။ ပြီးရင် Receive နှိပ်လိုက်ပါ။ (တစ်ရက်ကို 0.05 Sepolia ETH လောက် ရပါလိမ့်မယ်)။

Step 4: Balance စစ်ဆေးပါ

ခဏစောင့်ပြီးရင် MetaMask ထဲမှာ Sepolia ETH တွေ ရောက်လာတာကို တွေ့ရပါလိမ့်မယ်။ ဒီရလာတဲ့ ETH တွေက တန်ဖိုးမရှိပေမယ့် နောက်ပိုင်း Smart Contract တွေ ရေးတဲ့အခါ၊ Transaction တွေ စမ်းတဲ့အခါမှာ Gas Fee ပေးဖို့အတွက် အရမ်းအရေးပါပါတယ်။

နိဂုံး

Blockchain ပေါ်မှာ စမ်းသပ်မှုတွေလုပ်တိုင်း ကိုယ့်ပိုက်ဆံအကုန်မခံချင်ရင် Testnet နဲ့ Faucet အကြောင်းကို သေချာနားလည်ထားဖို့ လိုပါတယ်။ Day 6 ကျရင်တော့ ဒီ Testnet ETH တွေကို သုံးပြီး Transaction တွေ ဘယ်လိုလုပ်မလဲဆိုတာ ဆက်သွားကြပါမယ်။

Youtube : https://www.youtube.com/@lynnthelight

Facebook : https://www.facebook.com/letsfxckingo

မင်္ဂလာပါ၊ 100 Days of Blockchain ရဲ့ Day 4 ကနေ ကြိုဆိုပါတယ်။ ဒီနေ့မှာတော့ Blockchain နည်းပညာမှာ မရှိမဖြစ်လိုအပ်တဲ့ Wallet ဆိုတာဘာလဲ၊ သူဘယ်လို အလုပ်လုပ်သလဲဆိုတာကို Deep Dive လုပ်ပြီး ရှင်းပြပေးသွားမှာ ဖြစ်ပါတယ်။

သာမန်လူတစ်ယောက်အနေနဲ့ Wallet ဆိုတာ ပိုက်ဆံထည့်တဲ့ ပိုက်ဆံအိတ်လို့ပဲ မြင်လေ့ရှိကြပေမယ့် Blockchain Developer တစ်ယောက်အနေနဲ့ ဒီထက်ပိုပြီး နားလည်ထားဖို့ လိုပါတယ်။ တကယ်တော့ Wallet ဆိုတာ Blockchain နဲ့ Interact (အပြန်အလှန်ချိတ်ဆက်) လုပ်ဖို့အတွက် software တစ်ခု သို့မဟုတ် cryptographic key တွေကို သိမ်းဆည်းပေးထားတဲ့ နေရာတစ်ခုပဲ ဖြစ်ပါတယ်။

Wallet တစ်ခုဘယ်လို စတင်ဖြစ်ပေါ်လာသလဲ?

Wallet တစ်ခုကို create လုပ်တော့မယ်ဆိုရင် အရင်ဆုံး Random Words တွေကို generate လုပ်ရပါတယ်။ ပုံမှန်အားဖြင့် စကားလုံးပေါင်း ၂၅၆ လုံး (256 bits entropy) ရှိတဲ့ Random Words တွေကို အခြေခံပါတယ်။ အဲဒီကနေမှတဆင့် ကျွန်တော်တို့ Private Key ဆိုတာ ဖြစ်လာပြီး၊ Private Key ကနေမှတဆင့် Wallet ဆိုတာ ဖြစ်ပေါ်လာတာပါ။

ဒီ Process မှာ Key အမျိုးအစား (၂) ခု ပါဝင်ပါတယ်-

1. Private Key: ဒါက အရေးအကြီးဆုံးပါပဲ။ ပိုင်ရှင်ကလွဲပြီး ဘယ်သူမှ သိလို့မဖြစ်ပါဘူး။
2. Public Key: ဒါကတော့ သူများတွေကို ပေးလို့ရတဲ့ လိပ်စာသဘောမျိုးပါ။

MetaMask Wallet တည်ဆောက်ပုံ (Architecture)

ကျွန်တော်တို့ လက်တွေ့စမ်းသပ်နေတဲ့ MetaMask လို Browser Extension Wallet တွေမှာ Security အလွှာ (၃) ခုလောက် ရှိနေတာကို တွေ့ရပါလိမ့်မယ်။

1. The Extension Password (Local Lock)

MetaMask ကို စဖွင့်ဖွင့်ချင်းမှာ Password ပေးရပါတယ်။ ဥပမာ — 12345678 ပေါ့။ ဒီ Password က Blockchain နဲ့မဆိုင်ပါဘူး။ သင့်ကွန်ပျူတာ (Browser) မှာရှိတဲ့ MetaMask Extension ကို Lock ခတ်ထားရုံ သက်သက်ပါပဲ။ Password မေ့သွားရင် Reset ချလို့ရပါတယ်၊ ဒါပေမယ့် Wallet ကိုပြန်လိုချင်ရင်တော့ Seed Phrase လိုပါတယ်။

2. Secret Recovery Phrase (Seed Phrase)

ဒါကတော့ Master Key ပါပဲ။ စကားလုံး (၁၂) လုံးပါဝင်လေ့ရှိပါတယ်။ (ဥပမာ — brief, clarify, perfect, panda... စသဖြင့်ပေါ့)။ ဒီ (၁၂) လုံးကို ရလိုက်ပြီဆိုတာနဲ့ သင့် Wallet တစ်ခုလုံးကို ပိုင်ဆိုင်သွားပါပြီ။ ဒီစကားလုံး (၁၂) လုံးကနေ Private Key တွေကို ထုတ်ပေးလိုက်တာ ဖြစ်ပါတယ်။

3. Accounts (Private Keys)

စိတ်ဝင်စားဖို့ကောင်းတာက Wallet တစ်ခု (Seed Phrase တစ်ခု) အောက်မှာ Account တွေအများကြီး (Account 1, Account 2, Account 3) ထပ်ခွဲလို့ရပါတယ်။

• Account တစ်ခုချင်းစီမှာ သူ့ရဲ့ ကိုယ်ပိုင် Private Key (64 characters long hex string) ရှိပါတယ်။
• Seed Phrase ရှိရင် အဲ့ဒီ Account တွေအကုန်လုံးကို ပြန်ယူ (Recover) လို့ရပါတယ်။
• ဒါပေမယ့် Account 1 ရဲ့ Private Key ရှိရုံနဲ့ Account 2 ကို ဖွင့်လို့မရပါဘူး။

အောက်ဆုံးမှာ excalidraw link share ပေးထားလို့ဝင်ကြည့်လို့ရပါတယ်။

နည်းပညာပိုင်းအရ ဘယ်လိုအလုပ်လုပ်သလဲ? (The Math Behind It)

Wallet Address တစ်ခုရလာဖို့ အဆင့်ဆင့်ပြောင်းလဲပုံက ဒီလိုပါ-

1. Random Hex (64 words): ကွန်ပျူတာကနေ ဂဏန်းတွေကို ရမ်းသန်းရွေးထုတ်လိုက်ပါတယ်။ ဒါက Private Key ပါပဲ။ (ဥပမာ — 15da9919...)
2. Elliptic Curve Multiplication: ရလာတဲ့ Private Key ကို Elliptic curve လို့ခေါ်တဲ့ သင်္ချာနည်းလမ်းနဲ့ တွက်ချက်လိုက်တဲ့အခါ Public Key ထွက်လာပါတယ်။
3. Hashing: အဲဒီ Public Key ကိုမှ ထပ်ပြီး Hash လုပ်လိုက်တဲ့အခါ ကျွန်တော်တို့ မြင်နေကျ 0x... နဲ့စတဲ့ Wallet Address ကို ရရှိမှာ ဖြစ်ပါတယ်။

အရေးကြီးဆုံးအချက်: Wallet Address (ဥပမာ — 0xE32B...) က Bank Account Number နဲ့တူပါတယ်။ လူတိုင်းကို ပေးလို့ရပါတယ်။ Private Key နဲ့ Seed Phrase ကတော့ ATM PIN နံပါတ်နဲ့ တူပါတယ်။ ဘယ်သူ့ကိုမှ ပေးလို့မဖြစ်ပါဘူး။ သူများလက်ထဲရောက်သွားရင် သင့်ပိုက်ဆံတွေ အကုန်ပါသွားမှာပါ။

လက်တွေ့စမ်းသပ်ချက် (Transaction Demo)

Video ထဲမှာ ကျွန်တော် Sepolia Testnet ကိုသုံးပြီး Account 1 ကနေ Account 2 ကို ETH လွှဲပြခဲ့ပါတယ်။ သတိပြုရမှာက Blockchain ပေါ်မှာ Transaction တစ်ခုလုပ်တိုင်း Gas Fee ပေးရပါတယ်။ ကိုယ့်ရဲ့ Wallet ထဲက ပိုက်ဆံ (ETH) ကို တခြားလိပ်စာတစ်ခုဆီ ပို့လိုက်တာနဲ့ တပြိုင်နက် Network က သတ်မှတ်ထားတဲ့ အခကြေးငွေ ဖြတ်တောက်သွားမှာ ဖြစ်ပါတယ်။

နိဂုံး

ချုပ်ပြောရရင် Wallet ဆိုတာ Blockchain ပေါ်က ကိုယ့်ပိုင်ဆိုင်မှုတွေကို ထိန်းချုပ်ဖို့အတွက် သော့ (Keys) တွေကို သိမ်းဆည်းပေးထားတဲ့ Tool တစ်ခုပါပဲ။ အရေးကြီးဆုံးက ကိုယ့်ရဲ့ Seed Phrase နဲ့ Private Key ကို လုံခြုံစွာ သိမ်းဆည်းထားဖို့ပါပဲ။

Videoမှာအစအဆုံးရှင်းပြထားတာမို့ Video ကိုတော့ ကြည့်ဖို့ Recommend ပါတယ်ခင်ဗျ။

Youtube : https://youtu.be/uCmd9cNiXjg?si=e22wC1FjU_kZxW7Y

Facebook : https://www.facebook.com/letsfxckingo

Excalidraw : https://excalidraw.com/#json=dWe4s00uvH3XAMGVWqOsb,PeRWGMOgI5S0hOTowAWo8A

အားလုံးပဲ မင်္ဂလာပါ။ ဒီနေ့ကတော့ “100 Days of Blockchain” ရဲ့ Day 3 (၃ ရက်မြောက်နေ့) ဖြစ်ပါတယ်။ ဒီနေ့မှာတော့ Blockchain Development ရဲ့ အသက်ဖြစ်တဲ့ Smart Contracts တွေကို ရှင်းပြပေးသွားမှာ ဖြစ်ပါတယ်။ Smart Contract တွေ ဘယ်လိုအလုပ်လုပ်လဲဆိုတာကို နားလည်လွယ်အောင် ကျွန်တော်တို့အားလုံး ရင်းနှီးပြီးသားဖြစ်တဲ့ ကော်ဖီအရောင်းစက် (Vending Machine) လေးနဲ့ ဥပမာပေးပြီး ပြောပြသွားပါမယ်။

The Vending Machine Analogy (အရောင်းစက် သဘောတရား)

Smart Contract တွေအကြောင်း မပြောခင် Vending Machine တစ်ခု ဘယ်လိုအလုပ်လုပ်လဲဆိုတာကို အရင်ကြည့်ကြည့်ရအောင်။ သူက “Finite State Machine” လို့ခေါ်တဲ့ ယန္တရားအတိုင်း အဆင့် ၄ ဆင့်နဲ့ အလုပ်လုပ်ပါတယ်

1. State 1 (Selection): ကိုယ်သောက်ချင်တဲ့ ကော်ဖီကို ရွေးမယ်။
2. State 2 (Payment): သတ်မှတ်ထားတဲ့ ဈေးနှုန်းအတိုင်း ပိုက်ဆံထည့်မယ်။
3. State 3 (Verification): စက်က ပိုက်ဆံပြည့်မပြည့်နဲ့ ပစ္စည်း Stock ရှိမရှိ စစ်ဆေး (Verify) မယ်။
4. State 4 (Execution): အားလုံးမှန်ကန်တယ်ဆိုရင် ကော်ဖီထုတ်ပေးမယ်။ မှားနေရင် (ဥပမာ — ပိုက်ဆံမလောက်ရင်) မူလ State 1 ကို ပြန်ရောက်သွားမယ်။

Smart Contract ဆိုတာကလည်း ဒီ Logic အတိုင်း အလုပ်လုပ်တဲ့ Blockchain ပေါ်က Computer Program (Software) တစ်ခုပါပဲ။

Solidity နဲ့ ရေးသားခြင်း

Ethereum Blockchain ပေါ်မှာဆိုရင် Smart Contract တွေရေးဖို့အတွက် Solidity ဆိုတဲ့ Programming Language ကို အဓိက သုံးကြပါတယ်။ သူက Java လိုမျိုး Object-Oriented Language တွေနဲ့ Concept ဆင်တူပြီး၊ Class အစား Contract တွေကို အခြေခံတဲ့ “Contract-Oriented” Language တစ်ခုဖြစ်ပါတယ်။

Vending Machine တစ်ခုကို Solidity (version 0.8.20) နဲ့ ရေးမယ်ဆိုရင် အကြမ်းဖျင်း ဒီလိုပုံစံလေး ဖြစ်ပါလိမ့်မယ် -

Solidity

contract VendingMachine {
    // State Variables (ဆိုင်ရဲ့ ဒေတာများ)
    uint public price = 0.01 ether; // ဈေးနှုန်း
    uint public stock = 100;        // ပစ္စည်းအရေအတွက်
// ကော်ဖီဝယ်မယ့် Function
    function buy() external payable {
        // 1. ပိုက်ဆံလောက်မလောက် စစ်မယ်
        require(msg.value >= price, "Not enough Ether");
        
        // 2. ပစ္စည်းကျန်မကျန် စစ်မယ်
        require(stock > 0, "Out of stock");
        // 3. ပစ္စည်းထုတ်ပေးမယ် (stock ကို ၁ လျှော့မယ်)
        stock -= 1;
    }
}

The “Mind-Blowing” Shift: Web2 vs. Web3

ဒီအပိုင်းကတော့ Traditional Developer (Web2 သမား) တွေအတွက် Concept အပြောင်းအလဲ (Paradigm Shift) ဖြစ်သွားမယ့် အပိုင်းပါ။

Web2 Development (ဥပမာ Node.js သုံးတာမျိုး) မှာဆိုရင် Logic တွေ၊ Database တွေက Server တစ်လုံးတည်း (Centralized Server) ပေါ်မှာပဲ ရှိပါတယ်။ အဲ့ဒီ Server ပျက်သွားရင် ဒါမှမဟုတ် ဖျက်လိုက်ရင် Data တွေအကုန်ပျက်သွားမှာပါ။

Web3 မှာကျတော့ ကျွန်တော်တို့ရေးလိုက်တဲ့ VendingMachine Contract ကို Deploy လုပ်လိုက်တာနဲ့ သူက Server တစ်လုံးတည်းမှာ ရှိနေတာ မဟုတ်ပါဘူး။ Ethereum Blockchain ကြီးတစ်ခုလုံးအပေါ်ကို ရောက်သွားတာပါ။

အဓိကအချက်: Contract တစ်ခုကို Deploy လုပ်လိုက်တာနဲ့ သူ့ရဲ့ “State” (ဥပမာ — stock ဘယ်လောက်ကျန်လဲ ဆိုတဲ့ Data) က ကမ္ဘာပေါ်မှာရှိတဲ့ Blockchain Node တိုင်းမှာ သွားပြီး Duplicate ဖြစ်နေမှာပါ။ ဒါကို Global State လို့ ခေါ်ပါတယ်။

ဒါကြောင့် Blockchain ပေါ်ရောက်သွားတဲ့ Code (Smart Contract) တစ်ခုဟာ ဖျက်လို့မရတော့သလို (Immutable)၊ ဘယ်သူကမှလည်း ပိတ်ချလိုက်လို့ (Shut down) မရတော့ပါဘူး။

Gas Fees (လည်ပတ်စရိတ်)

ဒီလိုမျိုး Global Network ကြီးပေါ်မှာ Run တာဖြစ်တဲ့အတွက် အလကားတော့ မရပါဘူး။ အပေါ်က buy() function လိုမျိုး State ကို ပြောင်းလဲစေမယ့် (Stock လျှော့လိုက်တဲ့) အလုပ်မျိုးလုပ်မယ်ဆိုရင် Transaction Fee ပေးရပါတယ်။ ဒါကို Gas Fee လို့ခေါ်ပါတယ်။

• User က Gas fee ပေးရတယ်။
• Miner/Validator တွေက Code ကို Run ပေးတယ်။
• require တွေနဲ့ စစ်ဆေးလို့ အားလုံးမှန်ကန်တယ်ဆိုရင် တစ်ကမ္ဘာလုံးက Node တွေမှာရှိတဲ့ State (Stock အရေအတွက်) က ပြောင်းလဲသွားမှာ ဖြစ်ပါတယ်။

အနှစ်ချုပ်

Smart Contract ဆိုတာ Blockchain ပေါ်မှာ Run နေတဲ့ ပရိုဂရမ်တစ်ခုပါပဲ။ သူက လူကြားခံမလိုဘဲ ရေးသားထားတဲ့ Code အတိုင်း တိတိကျကျ အလုပ်လုပ်ပေးနိုင်တဲ့ အလိုအလျောက် စက်ယန္တရား (Automated Machine) တစ်ခုလိုပါပဲ။

Next Up: Logic တွေကို နားလည်ပြီဆိုတော့ ဒီ Contract တွေနဲ့ ဘယ်လို Interact လုပ်မလဲ? နောက်ရက် (Day 4) မှာတော့ Wallets နဲ့ Private Keys အကြောင်း ဆက်ပြောပြသွားပါမယ်။

Youtube : https://youtu.be/S9-4cHnXnnE

Facebook : https://www.facebook.com/letsfxckingo

အားလုံးပဲ မင်္ဂလာပါ။ မနေ့ကတော့ Blockchain ဆိုတာ ဘာလဲဆိုတာ ပြောပြခဲ့ပြီးပြီဆိုတော့ ဒီနေ့ Day 2 မှာတော့ ကမ္ဘာကျော် Blockchain ကြီးနှစ်ခုဖြစ်တဲ့ Bitcoin နဲ့ Ethereum အကြောင်း ဆက်ပြောကြမယ်ဗျာ။ ဒီနှစ်ခုက နာမည်ကြီးတာချင်းတူပေမဲ့ အလုပ်လုပ်ပုံချင်းကျတော့ တော်တော်လေး ကွာခြားပါတယ်။

Bitcoin ဆိုတာ ငွေကြေးသီးသန့်ပါပဲ

Bitcoin Blockchain ကို Satoshi Nakamoto က စထွင်ခဲ့တုန်းက ရည်ရွယ်ချက်က ရှင်းရှင်းလေးပါ။ “ကြားခံလူမလိုဘဲ တစ်ယောက်နဲ့ တစ်ယောက် ငွေလွှဲလို့ရမယ့် စနစ်” (P2P Electronic Cash System) တစ်ခု ဖြစ်လာဖို့ပါပဲ။

သူ့ရဲ့ အလုပ်လုပ်ပုံက ကျွန်တော်တို့ ပိုက်ဆံအိတ်ထဲက ငွေသား (Cash) သုံးတာနဲ့ တူပါတယ်။ နည်းပညာစကားနဲ့ဆိုရင်တော့ UTXO Model ပေါ့။ ဥပမာ — ကျွန်တော့်အိတ်ထဲမှာ ၅၀၀၀ တန်တစ်ရွက်၊ ၂၀၀၀ တန်တစ်ရွက် ရှိတယ်ဆိုပါစို့ (စုစုပေါင်း ၇၀၀၀ ပေါ့)။ လက်ဖက်ရည်ဆိုင်မှာ ၃၀၀၀ ကျပ်ရှင်းချင်ရင် ၃၀၀၀ တန် အတိအကျမရှိတဲ့အတွက် ၅၀၀၀ တန် ပေးလိုက်ရတယ်။ ပြီးမှ ဆိုင်က ၂၀၀၀ ပြန်အမ်းတာမျိုးပေါ့။ Bitcoin က အဲ့ဒီလို ပုံစံမျိုးနဲ့ အလုပ်လုပ်တာပါ။

တစ်ခုရှိတာက Bitcoin Blockchain က Transaction Data (ငွေရေးကြေးရေး) ကလွဲရင် တခြား Data တွေကို သိပ်ပြီး လက်မခံပါဘူး။

Ethereum ကျတော့ ဘာထူးလဲ?

Ethereum ကို ဖန်တီးခဲ့တဲ့ Vitalik Buterin ကျတော့ Bitcoin ကိုကြည့်ပြီး အားမရဘူး။ “Blockchain နည်းပညာက ပိုက်ဆံလွှဲဖို့တစ်ခုတည်း မဟုတ်ဘူး၊ တခြား Data တွေပါ သိမ်းလို့ရသင့်တယ်” ဆိုပြီး တွေးခဲ့တယ်။ ဒါနဲ့ပဲ Ethereum ပေါ်လာတာပါ။

Ethereum ကတော့ Account Model ကို သုံးပါတယ်။ ဒါကတော့ ဘဏ်အကောင့် နဲ့ သဘောတရား တူပါတယ်။ ကျွန်တော့်အကောင့်ထဲမှာ ၁ သိန်းရှိတယ်၊ သူငယ်ချင်းဆီ ၂ သောင်း လွှဲလိုက်မယ်ဆိုရင်… ကျွန်တော့်ဆီက ၂ သောင်းနှုတ်၊ ဟိုဘက်ကို ၂ သောင်းပေါင်းထည့်လိုက်ရုံပါပဲ။ Bitcoin လိုမျိုး ငွေအကြွေ ပြန်အမ်းနေစရာ မလိုတော့ဘူးပေါ့။

Ethereum ပေါ်မှာ ဘာမဆို လုပ်လို့ရတယ်

Ethereum ရဲ့ အသက်ကတော့ Smart Contract ပါပဲ။ သူက ပိုက်ဆံအပြင် တခြားအချက်အလက် (Any Information) ကိုပါ သိမ်းထားနိုင်တယ်။ ဥပမာ — ဘောလုံးပွဲ လောင်းကြေးထပ်မယ်ဗျာ။ “Newcastle နိုင်ရင် ဘယ်သူ့ကို ပေးမယ်၊ Chelsea နိုင်ရင် ဘယ်သူ့ကို ပေးမယ်” ဆိုတဲ့ စည်းကမ်းချက်တွေကို Code ရေးပြီး Blockchain ပေါ် တင်ထားလို့ရတယ်။ ပွဲပြီးတာနဲ့ အဲ့ဒီ Code (Smart Contract) က အလိုအလျောက် အလုပ်လုပ်ပြီး နိုင်တဲ့သူကို ပိုက်ဆံလွှဲပေးသွားမှာ။ ကြားက ဒိုင်ကို ယုံစရာမလိုတော့ဘူး။

အနှစ်ချုပ်

တိုတိုပြောရရင်တော့…

• Bitcoin ဆိုတာ ငွေကြေးလွှဲပြောင်းဖို့ သက်သက်ပါပဲ။ သူ့ရဲ့ Token က BTC ပါ။
• Ethereum ကျတော့ ငွေကြေးတင်မကဘဲ တခြား App တွေ၊ Smart Contract တွေပါ run လို့ရတဲ့ Platform ကြီးတစ်ခုပါ။ သူ့ရဲ့ Token ကတော့ Ether (ETH) ပါ။

ကဲ… ဒီလောက်ဆိုရင် ဒီကောင်ကြီးနှစ်ကောင် ဘာကွာလဲဆိုတာ သဘောပေါက်လောက်ပြီ ထင်ပါတယ်။ မနက်ဖြန်ကျမှ ဆက်တွေ့ကြတာပေါ့ဗျာ။

Youtube : https://youtu.be/gct3jZEdOIc?si=HBA-9S2G74tya80t

Facebook : https://www.facebook.com/letsfxckingo

မင်္ဂလာပါ။ ဒီနေ့ကတော့ 100 Days of Blockchain အစီအစဉ်ရဲ့ ပထမဆုံးရက် (Day 1) ဖြစ်ပါတယ်။ ဒီအစီအစဉ်မှာ Blockchain နည်းပညာနဲ့ ပတ်သက်ပြီး အခြေခံမရှိသေးတဲ့သူတွေပါ နားလည်နိုင်အောင် ရှင်းပြသွားမှာ ဖြစ်ပါတယ်။

ဒီနေ့ Day 1 မှာတော့ Blockchain ဆိုတာ ဘာလဲဆိုတာကို နားလည်ဖို့အတွက် လက်ရှိ website တွေ ဘယ်လိုအလုပ်လုပ်လဲဆိုတာနဲ့ ယှဉ်ပြီး လေ့လာကြည့်ကြပါမယ်။

လက်ရှိ Web 2.0 စနစ်များ (Client-Server Model)

ကျွန်တော်တို့ နေ့စဉ်သုံးနေတဲ့ Facebook လို Application တွေကို နမူနာထား စဉ်းစားကြည့်ရအောင်။

ဥပမာ — User A နဲ့ User B ဆိုပြီး ရှိမယ်။ သူတို့နှစ်ယောက်လုံး Facebook ကို သုံးနေကြတယ်။ User A က သူ့ဖုန်းထဲက ဓာတ်ပုံတစ်ပုံကို Facebook ပေါ် တင်လိုက်တယ် ဆိုပါစို့။ အဲ့ဒီပုံက ဘယ်ကို ရောက်သွားမလဲဆိုတော့ Facebook ရဲ့ Database Server ဆီကို ရောက်သွားပြီး သိမ်းလိုက်ပါလိမ့်မယ်။

User B က အဲ့ဒီပုံကို ကြည့်ချင်တယ်ဆိုရင် Facebook ရဲ့ Server ကနေတစ်ဆင့် လှမ်းကြည့်ရတာပါ။ ဒီနေရာမှာ အသုံးပြုသူတွေရဲ့ ဖုန်း/ကွန်ပျူတာတွေကို Client လို့ခေါ်ပြီး၊ အချက်အလက်တွေကို သိမ်းထားပေးတဲ့ ဗဟိုစက်ကြီးကိုတော့ Server လို့ ခေါ်ပါတယ်။ ဒါကို Client-Server Architecture လို့ သတ်မှတ်ပါတယ်။

ဒီစနစ်မှာ အားနည်းချက်ကတော့ အချက်အလက်အားလုံးကို Server တစ်နေရာတည်းက ထိန်းချုပ်ထားတာ ဖြစ်ပါတယ်။

မိသားစု စာရင်းအင်း ဥပမာ (Centralized vs Decentralized)

Blockchain သဘောတရားကို ပိုရှင်းသွားအောင် မိသားစု (၂) စုရဲ့ ငွေရေးကြေးရေး စာရင်းမှတ်ပုံချင်း ယှဉ်ပြီး ကြည့်ရအောင်။

Family A (Centralized System)

ဒီမိသားစုမှာ အဖေ၊ အမေ၊ သား၊ သမီး (၄) ယောက်ရှိတယ်။ အိမ်ရဲ့ ငွေစာရင်း ဝင်ငွေ/ထွက်ငွေ အားလုံးကို အမေလုပ်သူကပဲ စာရင်းအုပ်နဲ့ မှတ်ထားတယ်။ သားက ပိုက်ဆံလိုလို့ တောင်းရင် အမေက သူ့စာရင်းအုပ်ထဲမှာ မှတ်ပေးလိုက်တယ်။

ဒီစနစ်ရဲ့ ပြဿနာက -

• အမေက စာရင်းအုပ်ကို တစ်ယောက်တည်း ကိုင်ထားတာ ဖြစ်တဲ့အတွက် တကယ်လို့ အမေက စာရင်းမှားရေးလိုက်ရင် သော်လည်းကောင်း၊ ပြင်ရေးလိုက်ရင် သော်လည်းကောင်း ကျန်တဲ့လူတွေ မသိနိုင်ပါဘူး။
• စာရင်းအုပ် ပျောက်သွားရင်လည်း မှတ်တမ်းတွေ အကုန်ပျောက်သွားမှာ ဖြစ်ပါတယ်။

Family B (Decentralized System)

ဒီမိသားစုမှာကျတော့ ပုံစံတစ်မျိုး ပြောင်းလိုက်မယ်။ အိမ်မှာရှိတဲ့ (၄) ယောက်လုံးက စာရင်းအုပ် တစ်အုပ်စီ ကိုယ်စီ ကိုင်ထားကြမယ်။

• အိမ်ရဲ့ ဝင်ငွေ/ထွက်ငွေ တစ်ခုခု (Transaction) ဖြစ်တိုင်းမှာ (၄) ယောက်လုံးက သူတို့ရဲ့ စာရင်းအုပ် အသီးသီးမှာ လိုက်မှတ်ကြတယ်။
• ဥပမာ — အဖေက သားကို မုန့်ဖိုးပေးလိုက်တယ်ဆိုရင် အဲ့ဒီအကြောင်းအရာကို (၄) ယောက်လုံးက လိုက်မှတ်တယ်။
• ဒီတော့ တစ်ယောက်ယောက်က လိမ်ချင်လို့ သူ့စာရင်းအုပ်မှာ ပြင်ရေးရင်တောင် ကျန်တဲ့ (၃) ယောက်ရဲ့ စာရင်းအုပ်နဲ့ တိုက်စစ်လိုက်ရင် မိသွားမှာ ဖြစ်ပါတယ်။

Family A က လက်ရှိဘဏ်တွေ၊ ကုမ္ပဏီတွေ သုံးနေတဲ့ Centralized စနစ်ဖြစ်ပြီး၊ Family B ကတော့ Blockchain သုံးထားတဲ့ Decentralized စနစ်နဲ့ တူပါတယ်။

Blockchain Architecture

Blockchain နည်းပညာမှာ အချက်အလက်တွေကို သိမ်းဆည်းတဲ့အခါ Block လေးတွေ အနေနဲ့ သိမ်းဆည်းပါတယ်။

1. Genesis Block (First Block): ပထမဆုံး စလုပ်တဲ့ Block ပါ။ ဥပမာ — ကျွန်တော့်မှာ ပိုက်ဆံ $100 ရှိတယ်ဆိုပြီး စမှတ်လိုက်မယ်။
2. Transaction: နောက်ထပ် ကျွန်တော်က သူငယ်ချင်းတစ်ယောက်ကို $50 ပေးလိုက်တယ်ဆိုရင်၊ ကျွန်တော့်ဆီမှာ $50 ကျန်မယ်၊ သူငယ်ချင်းဆီမှာ $50 ရောက်သွားမယ်။ ဒီအပြောင်းအလဲကို နောက်ထပ် Block တစ်ခုအနေနဲ့ မှတ်တမ်းတင်ပြီး ပထမ Block နဲ့ ချိတ်ဆက်လိုက်ပါတယ်။

ဒီလို Block တွေ တစ်ခုနဲ့တစ်ခု ဆက်နွယ်ပြီး ချိတ်ဆက်ထားတာကို Blockchain လို့ ခေါ်တာပါ။

Nodes (ကွန်ပျူတာများ ချိတ်ဆက်ခြင်း)

Blockchain တစ်ခုကို လူတစ်ယောက်တည်းက Run လို့ မရပါဘူး။ ကမ္ဘာအနှံ့က ကွန်ပျူတာတွေ (Nodes) အများကြီး ချိတ်ဆက်ထားရပါတယ်။ ကျွန်တော့် ကွန်ပျူတာ (Node) တစ်ခုတည်းမှာပဲ Data ရှိနေတာ မဟုတ်ပါဘူး။ သူငယ်ချင်းတွေဖြစ်တဲ့ Howy တို့၊ Lynn တို့ရဲ့ ကွန်ပျူတာတွေ (Nodes) မှာလည်း ဒီ Blockchain မှတ်တမ်းတွေ အတူတူ ရှိနေမှာ ဖြစ်ပါတယ်။

အရေးကြီးဆုံး အချက်ကတော့ Synchronization ပါ။ Blockchain ထဲမှာ ငွေလွှဲပြောင်းမှု (Transaction) တစ်ခု ဖြစ်လိုက်တာနဲ့ ကွန်ပျူတာ (Node) အားလုံးမှာရှိတဲ့ မှတ်တမ်းတွေက တပြိုင်နက်တည်း Update ဖြစ်သွားရပါမယ်။ ဒါမှသာ Family B ဥပမာလိုပဲ အားလုံးမှာ မှန်ကန်တဲ့ စာရင်းအင်း တစ်ခုတည်း ရှိနေမှာ ဖြစ်ပါတယ်။

Summary

အတိုချုပ်ရရင် Blockchain ဆိုတာ ဗဟိုထိန်းချုပ်မှု မရှိဘဲ (Decentralized)၊ ကွန်ပျူတာ Node ပေါင်းများစွာကနေ မှတ်တမ်းတွေကို မျှဝေထိန်းသိမ်းထားတဲ့ စာရင်းအင်း နည်းပညာ (Distributed Ledger Technology) တစ်ခု ဖြစ်ပါတယ်။

ဒီနေ့ Day 1 မှာတော့ ဒီလောက်ပါပဲ။ မနက်ဖြန် Day 2 မှာတော့ လူသိများတဲ့ Bitcoin နဲ့ Ethereum Blockchain တွေအကြောင်း ဆက်ပြီး ဆွေးနွေးသွားပါမယ်။

Youtube : https://youtu.be/gct3jZEdOIc?si=HBA-9S2G74tya80t

Facebook : https://www.facebook.com/letsfxckingo

A newbie developer’s journey building with Circle BridgeKit, Arc Testnet, and Base

TLDR: I went from struggling with manual CCTP implementations to shipping a production-ready bridge dapp in 48 hours using Circle’s BridgeKit. Here’s everything I learned about building cross-chain infrastructure, Base Account integration, and why the right abstractions matter.

The Beginning: Wide-Eyed and Lost

Two days ago, I had an idea: build a bridge to move USDC between Arc Testnet and Base Sepolia. Simple enough, right?

Narrator: It was not simple.

I started where every developer starts — reading documentation. Circle’s Cross-Chain Transfer Protocol (CCTP) looked amazing. The ability to burn USDC on one chain and mint it natively on another, without wrapped tokens or liquidity pools, felt like the future of cross-chain transfers.

But the documentation was… extensive. Really extensive.

The Manual Implementation Nightmare

My first attempt involved manually implementing CCTP. I needed to:

1. Approve the USDC token for spending by the TokenMessenger contract

2. Burn the USDC using depositForBurn()

3. Wait for Circle’s attestation service to confirm the burn

4. Fetch the attestation signature

5. Switch to the destination chain

6. Receive the USDC using receiveMessage()

Each step had its own pitfalls like getting contract addresses right, understanding CCTP domain IDs, handling attestation polling, managing chain switching, and dealing with RPC reliability issues.

After six hours of debugging, I had something that technically worked but felt fragile. The code was sprawling across multiple files. Error handling was a mess. And I hadn’t even started thinking about UI/UX.

The Discovery: Circle BridgeKit

Exhausted and searching for solutions, I stumbled upon Circle’s BridgeKit documentation. The tagline caught my attention:

“Simplify cross-chain USDC transfers with 4 lines of code”

I was skeptical. How could four lines replace my 200+ line implementation?

const result = await kit.bridge({
from: { adapter, chain: sourceChainName },
to: { adapter, chain: destinationChainName },
amount: amount,
});

That’s it. Four lines.

BridgeKit handles:

• Token approvals
• Burn transactions
• Attestation polling
• Message receiving
• Error recovery
• Transaction status updates

I spent the next hour ripping out my manual implementation and replacing it with BridgeKit. The difference was night and day.

Building the Bridge: Arc ↔ Base

Understanding Arc Testnet

Arc Testnet is fascinating because USDC is the native gas token. Unlike traditional chains where you need ETH for gas, Arc uses USDC for everything. This creates a unique UX challenge — users don’t need two token balances, just USDC.

Chain Details:

• Chain ID: 5042002
• RPC: https://rpc.testnet.arc.network
• Native Token: USDC (0x3600000000000000000000000000000000000000)
• CCTP Domain: 7

The Architecture

Here’s how the bridge works under the hood:

Frontend Stack:

• React 18 + Vite for blazing fast development
• Wagmi 2.12 for Ethereum interactions
• Tailwind CSS for utility-first styling
• Circle BridgeKit for cross-chain transfers

Smart Contract Integration:

• Circle’s CCTP TokenMessenger contracts
• USDC token contracts on both chains
• Custom adapter using adapter-viem-v2

User Flow:

1. Connect wallet (Base Account, MetaMask, or Coinbase Wallet)
2. Select source chain (Arc Testnet or Base Sepolia)
3. Enter USDC amount
4. Click “Bridge”
5. Approve transaction in wallet
6. Wait for attestation (usually 10–20 seconds)
7. Receive USDC on destination chain automatically

The Base Ecosystem Integration

One of my favorite parts of this project was integrating Base’s identity infrastructure.

Base Account & Basename

Base Account is Coinbase’s smart wallet solution. It’s an ERC-4337 account abstraction wallet that enables:

• Gasless transactions (through paymasters)
• Social recovery
• Batch transactions
• Native Basename support

Basenames are human-readable identities on Base (like ENS for Base). Instead of showing 0x742d…, my app displays the user’s Basename if they have one:

// Fetch Basename
const basename = await getName({
address: userAddress,
chain: base
});
// Display: "florject.base.eth" instead of "0x742d…"

This simple integration makes the app feel more personal and user-friendly.

The UI/UX Journey: From Complex to Simple

First Iteration: Gradient Overload

My initial design used purple, blue, and cyan gradients everywhere. It looked “modern” but felt overwhelming. Every button was a rainbow, every card had three colors.

Second Iteration: Minimalism Wins

I stripped everything back to black, white, and blue. That’s it. Three colors.

Black: Text and borders

White: Backgrounds

Blue: Accents and interactive elements

The result? A cleaner, more focused interface that doesn’t distract from the core functionality — bridging USDC.

Smart Balance Display

Since Arc Testnet uses USDC as the native token, I implemented smart balance detection:

const isArcTestnet = chain?.id === arcTestnet.id;
// On Arc: Show only USDC balance
// On Base: Show ETH + USDC balances

This prevents confusion and reduces cognitive load for users.

Network Addition: Solving the UX Problem

A major hurdle was that most wallets don’t have Arc Testnet pre-configured. Users would try to switch chains and get errors like:

Error: Unrecognized chain ID 0x4cef52

I built an auto-add network feature that detects missing networks and prompts users to add them automatically:

async function switchToChain(switchChain, chainId, chainConfig) {
try {
await switchChain({ chainId });
} catch (error) {
// If chain not found, add it automatically
if (error.code === 4902) {
await addNetworkToWallet(chainConfig);
await switchChain({ chainId });
}}}

Now when users try to bridge, the app seamlessly adds any missing networks to their wallet. One less friction point.

Technical Deep Dive: How BridgeKit Works

For the developers reading this, here’s what happens behind the scenes when you call kit.bridge():

Initialization

BridgeKit creates a viem adapter from your wallet provider:

const adapter = await createAdapterFromProvider({
provider: window.ethereum,
});

Chain Name Mapping

BridgeKit uses specific chain names. I map chain IDs to these names:

const sourceChainName = sourceChainId === arcTestnet.id
? "Arc_Testnet"
: "Base_Sepolia";

The Magic Bridge Call

This single call orchestrates the entire cross-chain transfer:

const result = await kit.bridge({
from: { adapter, chain: sourceChainName },
to: { adapter, chain: destinationChainName },
amount: amount,
});

Transaction Tracking

BridgeKit returns transaction hashes for each step:

{
approvalTxHash: "0x…", // USDC approval
burnTxHash: "0x…", // Burn on source chain
mintTxHash: "0x…" // Mint on destination chain
}

Status Updates

I display real-time status updates as the bridge progresses:

“Initializing transfer…”

“USDC Approved!”

“USDC Burned!”

“Waiting for attestation…”

“USDC Minted!”

“Transfer completed successfully!”

Challenges and Solutions

Challenge 1: CCTP Domain Configuration

Problem: Arc Testnet’s CCTP domain wasn’t documented clearly.

Solution: Found it through Circle’s support and community channels. Arc Testnet uses domain 7.

Challenge 2: Arc’s Native USDC

Problem: Most examples assume ETH as the gas token.

Solution: Built custom balance display logic that detects Arc Testnet and shows only USDC.

Challenge 3: Wallet Network Support

Problem: Users frustrated by “chain not found” errors.

Solution: Implemented automatic network addition with the wallet_addEthereumChain RPC method.

Challenge 4: Attestation Timing

Problem: Users confused during the 10–20 second attestation wait.

Solution: Added detailed progress steps showing exactly what’s happening at each stage.

Key Lessons for Builders

1. Use the Right Abstractions

Don’t reinvent the wheel. BridgeKit saved me days of work and resulted in more reliable code than my manual implementation.

2. UX Beats Features

A simple, focused interface with smooth network addition beats a feature-rich app with friction points.

3. Test on Real Networks Early

I wasted time building against local nodes. Testing on Arc Testnet and Base Sepolia immediately revealed real-world issues.

4. Status Updates Matter

Users tolerate waiting if they know what’s happening. Detailed status messages transformed the experience.

5. Embrace Chain-Specific Quirks

Arc’s USDC-as-gas-token model initially seemed like a hassle. Embracing it led to a cleaner UX.

The Tech Stack Breakdown

Frontend Framework:

• React 18.3.1
• Vite 5.4.11
• Tailwind CSS 3.4.17
• Blockchain Libraries:
• Wagmi 2.12.29 (React hooks for Ethereum)
• Viem 2.38.1 (TypeScript Ethereum library)
• @circle-fin/bridge-kit 0.4.2 (CCTP abstraction)
• @circle-fin/adapter-viem-v2 0.4.2 (Viem integration)

Identity & Social:

@coinbase/onchainkit 0.36.12 (Base Account & Basename)

Chains:

1. Arc Testnet (Chain ID: 5042002)
2. Base Sepolia (Chain ID: 84532)

Future Explorations

This is just the beginning. Here’s what I’m exploring next:

1. Multi-Hop Bridging

Bridge through multiple chains in a single transaction. Arc → Base → Arbitrum in one click.

2. Gasless Bridging

Using Base Account’s paymaster features to enable gasless bridges for new users.

3. Production Deployment

Moving from testnet to mainnet with Arc and Base production networks.

4. Intent-Based Bridging

Let users specify destination and amount; the app finds the best route automatically.

5. Bridge Analytics

Track volume, most popular routes, and average completion times.

Try It Yourself

The bridge is live on testnet. Get test USDC from Arc Testnet Faucet, test ETH from Coinbase Faucet for Base Sepolia, and connect using Base Account, MetaMask, or Coinbase Wallet.

All code is open source. Check out the repo to see how it works, fork it, and build your own cross-chain applications.

Acknowledgments

Building this wouldn’t have been possible without:

@MoxiaJinVII — For Arc Testnet support and documentation

Circle Team — For BridgeKit and amazing CCTP infrastructure

@jessepollak & @base — For building Base and the incredible tooling ecosystem

Farcaster Community — For Frame SDK and integration support

Closing Thoughts

Two days ago, I knew almost nothing about cross-chain bridges. Today, I have a working bridge that’s actually simple to use.

The crypto infrastructure layer is maturing rapidly. Tools like BridgeKit, Base Account, and Basename are abstracting away complexity, making it possible for builders like me to ship real products quickly.

If you’re thinking about building cross-chain applications, don’t let the complexity intimidate you. Start small, use the right tools, and focus on user experience. The infrastructure is here. The community is supportive. The only question is: what will you build?

Want to connect?

GitHub: https://github.com/lynnmeanslight

X : https://x.com/lynnthelight

Building something with CCTP or Base? I’d love to hear about it. Drop a comment or reach out directly.

This article documents my first cross-chain dapp. It’s rough around the edges, but it works. And that’s what matters — shipping and learning in public.

Repo link : https://github.com/lynnmeanslight/arc_bridge

Demo link : https://arc-bridge.vercel.app/