ဤဆောင်းပါးတွင်၊ ကျွန်ုပ်တို့သည် Go blockchain ဖွံ့ဖြိုးတိုးတက်မှုကို အစမှစ၍ အာရုံစိုက်ပါမည်။ သို့သော်၊ ကျွန်ုပ်တို့မစတင်မီ၊ သင်သည် Golang ရှိ အခြေခံသဘောတရားများနှင့် အကျွမ်းတဝင်ရှိရန် သေချာသင့်သည်။ မဟုတ်ပါက၊ သင်သည် ပဏာမသဘောတရားများကိုဖြတ်သန်းပြီးနောက် blockchain သို့ပြန်လာပါက ပညာရှိရာရောက်ပါသည်။
ဒီတော့ ခေါင်းစဉ်ကို တည့်တည့်သွားကြည့်ရအောင်။
လမ်းညွှန်အသစ်ဖြင့် စတင်သည်။
စတင်ရန် လမ်းညွှန်အသစ်တစ်ခု တည်ဆောက်ပါမည်။ ဤလမ်းညွှန်တွင် "blockchain" အမည်ရှိနေသည်ဟု ယူဆကြပါစို့။ ကျွန်ုပ်တို့သည် Command Prompt တွင်ကုဒ်ကိုရိုက်ပါလိမ့်မည် (သို့မဟုတ် သင်သည် macOS သို့မဟုတ် Linux ကိုအသုံးပြုနေပါက၊ သင်သည် Terminal ကိုအသုံးပြုရပါမည်)။ ထို့ကြောင့်၊ ကျွန်ုပ်တို့သည်-
cd go-workspace
mkdir blockchain
cd blockchain
ကုဒ် ။
VS Code ပွင့်လာသည်နှင့်အမျှ၊ Command Prompt တွင် Go module တစ်ခုကို ဖန်တီးပါမည်။ ငါတို့ဘယ်လိုလုပ်မလဲ။ ကောင်းပြီ၊ ကျွန်ုပ်တို့ရိုက်ပါ
mod init github.com/golang-company/blockchain ကိုသွားပါ။
main.go တွင် coding
ထို့နောက် 'main.go' ဟု အမည်ပေးထားသော Go အရင်းအမြစ်ဖိုင်ကို ဖန်တီးပြီး ၎င်းတွင် ကုဒ်ကို ရိုက်ထည့်ပါမည်။ သို့သော် ဦးစွာ blockchain ဆိုသည်မှာ ဘာလဲ နားလည်ကြပါစို့။ တစ် blockchain သက်တူရွယ်တူများစွာကြားတွင် ဗဟိုချုပ်ကိုင်မှု လျှော့ချပြီး ဖြန့်ဝေသည့် အများသူငှာ ဒေတာဘေ့စ်အဖြစ် သတ်မှတ်နိုင်သည်။ Blockchain သည် node တစ်ခုမှ မမှန်ကန်သော ဒေတာကို ထုတ်လုပ်နေသော်လည်း ဒေတာဘေ့စ်ကို ကိုယ်တိုင်မှန်ကန်စေရန် ခွင့်ပြုပေးသည်။
အများအားဖြင့်၊ blockchain တစ်ခုရှိ ဘလောက်တစ်ခုသည် ဒေတာဘေ့စ်တွင်ကျွန်ုပ်တို့မျှဝေထားသောဒေတာ၊ hash နှင့် ယခင်လုပ်ကွက်၏ cryptographic hash တို့ပါဝင်သည်။
ဒါဆို အဆင်သင့်ဖြစ်ပြီလား blockchain ဖွံ့ဖြိုးတိုးတက်ရေးကိုသွားပါ။? မိုက်တယ်! စလိုက်ကြစို့။
Programming အပိုင်း
ဤကဏ္ဍတွင်၊ ကျွန်ုပ်တို့သည် main.go ဖိုင်ကို ကြည့်ရှုပါမည်။
package ပင်မ
တင်သွင်းခြင်း (
"ဘိုက်"
“crypto/sha256”
"Fmt"
)
Cryptoblock struct ကိုရိုက်ပါ {
Hash [] byte
ဒေတာ [] byte
PrevHash [] byte
}
- သင်တွေ့မြင်ရသည့်အတိုင်း struct တစ်ခုကို ဖန်တီးထားခြင်းဖြစ်သည်။
func (c *Cryptoblock) BuildHash() {
အသေးစိတ်အချက်များ := bytes.Join([][] byte{c.Data၊ c.PrevHash}၊ []byte{})
hash := sha256.Sum256(အသေးစိတ်)
c.Hash = hash[ : ]
}
- ယခု ကျွန်ုပ်တို့သည် ဒေတာနှင့် ယခင် hash ပေါ်မူတည်၍ hash တစ်ခုကို ဖန်တီးနိုင်စေမည့် နည်းလမ်းတစ်ခုကို တည်ဆောက်ပါမည်။ ကျွန်ုပ်တို့ ၎င်းကိုအသုံးပြုနေသောကြောင့် "bytes" စာကြည့်တိုက်ကို တင်သွင်းပါမည်။
- နောက်တစ်ဆင့်မှာ အသေးစိတ်အချက်များဟုခေါ်သော variable တစ်ခုကိုဖန်တီးပြီး data type bytes ကိုအသုံးပြုပါ။ ဘိုက်ချပ်များကို ချိတ်ဆက်ရန် Join() ကို အသုံးပြုပါမည်။
အသေးစိတ်အချက်များ := bytes.Join([][] byte{c.Data၊ c.PrevHash}၊ []byte{})
ဤတွင်၊ ကျွန်ုပ်တို့သည် 2D အချပ်ကိုယူပြီး၊ c.Data နှင့် ယခင် hash ကို ပို့ပါသည်။ ထို့နောက် ဘိုက်အလွတ်အချပ်များကို ပေါင်းစပ်ပါမည်။
- ၎င်းကိုလုပ်ဆောင်ပြီးနောက်၊ အသေးစိတ်အချက်အလက်များအပေါ် sum256 hashing function ၏အကူအညီဖြင့် အမှန်တကယ် hash ကို ဖန်တီးနေပါသည်။ sha256 စာကြည့်တိုက်ကို တင်သွင်းမည်ဖြစ်သောကြောင့် ၎င်းကို ကျွန်ုပ်တို့အသုံးပြုနိုင်ပါသည်။
- ထို့နောက်၊ ကျွန်ုပ်တို့သည် ဘလောက်အတွက် ဖန်တီးထားသော hash ကို Hash အကွက်ထဲသို့ တွန်းပို့သည်။
func BuildBlock (ဒေတာစာတန်း၊ prevHash [] byte) *Cryptoblock {
ပိတ်ဆို့ခြင်း := &Cryptoblock{[]byte{}, []byte(ဒေတာ), prevHash}
block.BuildHash()
ပြန်ပေးတုံး
}
- Block ကိုဖန်တီးနိုင်စေမည့် Function တစ်ခုကို ယခုတည်ဆောက်ပါမည်။ လုပ်ဆောင်ချက်သည် ထည့်သွင်းမှုအဖြစ် ဒေတာစာကြောင်းတစ်လိုင်းကို လက်ခံသည်၊ ယခင်ဘလောက်မှ input အဖြစ် prevHash ကို လက်ခံပြီး Cryptoblock သို့ ရည်ညွှန်းချက်ကို ထုတ်သည်။ block constructor ကို အသုံးပြု၍ block ကို တည်ဆောက်ပါမည်။
- &Cryptoblock သည် block ကိုရည်ညွှန်းချက်အဖြစ် လုပ်ဆောင်သည်။ Hash အကွက်အတွက်၊ ကျွန်ုပ်တို့သည် ဘိုက်အလွတ်တစ်ခုကို ပေါင်းစပ်ထားသည်။ ဒေတာအကွက်အတွက်၊ ကျွန်ုပ်တို့သည် ဒေတာစာကြောင်းကိုယူပြီး ၎င်းကို ဘိုက်အချပ်များအဖြစ်သို့ ပြောင်းပါသည်။ ထို့အပြင် ကျွန်ုပ်တို့သည် PrevHash ကို PrevHash အကွက်တွင် ပေါင်းစပ်ထားသည်။
- နောက်ဆုံးအနေနဲ့ block မှာရှိတဲ့ BuildHash() ကိုခေါ်ပြီး block ကိုပြန်ပေးတယ်။
BlockChain struct ကိုရိုက်ပါ {
ပိတ်ဆို့ခြင်း []*Cryptoblock
}
- blockchain ကိုဖော်ပြရာတွင်ကူညီမည့်အမျိုးအစားတစ်ခုလိုအပ်သည်။ ပြီးတော့ ဒါကို ပြီးမြောက်ဖို့ စည်းမျဥ်းတစ်ခု အကောင်အထည်ဖော်ခဲ့တယ်။ BlockChain struct အမျိုးအစားကို Cryptoblock သို့ ညွှန်ပြသည့် array တစ်ခုဖြင့် ဖွဲ့စည်းထားသည်။
func (ကွင်းဆက် *BlockChain) AddBlock(ဒေတာစာကြောင်း) {
prevBlock := chain.blocks[len(chain.blocks)-1]
အသစ် := BuildBlock(ဒေတာ၊ prevBlock.Hash)
chain.blocks = append(chain.blocks၊ အသစ်)
}
- ဤတွင်၊ ကျွန်ုပ်တို့သည် ကွင်းဆက်သို့ ပိတ်ဆို့ခြင်းသို့ ချိတ်ဆက်နိုင်စေမည့် နည်းလမ်းတစ်ခုကို ဖန်တီးနေပါသည်။ နည်းလမ်းသည် blockchain pointer ကိုရယူသည်။ ၎င်းကို လိုက်နာခြင်းဖြင့် ဒေတာ စာကြောင်းတစ်ခုကို လက်ခံသည်။
- chain.blocks ကိုခေါ်ပါ၊ ကျွန်ုပ်တို့သည် blockchain ရှိယခင်ဘလောက်သို့ရောက်ပါသည်။ ထို့နောက်၊ ကျွန်ုပ်တို့သည် blockchain [len(chain.blocks)-1] ၏ အရှည်ကို ကျော်သွားသည်။
- ကိန်းရှင်အသစ်တွင်၊ ကျွန်ုပ်တို့သည် BuildBlock လုပ်ဆောင်ချက်ကိုခေါ်ဆိုနေပြီး ကျွန်ုပ်တို့သည် data string နှင့် prevBlock.Hash ကိုဖြတ်သန်းနေပါသည်။
- နောက်ဆက်တွဲလုပ်ဆောင်ချက်ကို အသုံးပြုခြင်းဖြင့် ၎င်းကို chain.blocks များသို့ပေါင်းထည့်ခြင်းဖြင့်၊ ထို့နောက် blockchain တွင် block အသစ်ကို ချိတ်ဆက်ပါ။
func Inception() *Cryptoblock {
BuildBlock(“Inception”၊ []byte{}) ကို ပြန်ပေးသည်။
}
- နောက်တစ်ဆင့်မှာ blockchain ၏ပထမဆုံး block ကိုဖော်ပြမည့် Inception ဟုခေါ်သောလုပ်ဆောင်ချက်ကိုဖန်တီးရန်ဖြစ်သည်။ ပြီးတော့ လုပ်ဆောင်ချက်ထဲမှာ BuildBlock အသစ်တစ်ခုကို ပထမဘလောက်မှာရှိတဲ့ ဒေတာတွေနဲ့အတူ ပြန်ပေးမယ်။ ဒီမှာ။ ကျွန်ုပ်သည် “Inception” နှင့် ယခင် hash အလွတ်တစ်ခုကို ကိုယ်စားပြုသည့် bytes အပိုင်းတစ်ခုကို ပေါင်းစပ်ထားသည်။
func InitBlockChain() *BlockChain {
ပြန်ပေး &BlockChain{[]*Cryptoblock{Inception()}}
}
- ပထမဆုံး blockchain ကိုဖန်တီးရန်အတွက်၊ ကျွန်ုပ်သည် InitBlockChain လုပ်ဆောင်ချက်ကိုမိတ်ဆက်ပေးခဲ့သည်။ ဤတွင်၊ ကျွန်ုပ်သည် BlockChain အား သီးခြားရည်ညွှန်းချက်ကို ပြန်ပေးပါသည်။ ထို့နောက်၊ ကျွန်ုပ်တို့သည် Inception လုပ်ဆောင်ချက်ကိုခေါ်ဆိုသည့်နေရာတွင် Cryptoblock ၏ array တစ်ခုကိုတည်ဆောက်သည်။
function main() {
ကွင်းဆက် := InitBlockChain()
ကွင်းဆက်။AddBlock(“စတင်ပြီးနောက် ပထမပိတ်ဆို့ခြင်း”)
chain.AddBlock("စတင်ပြီးနောက် ဒုတိယပိတ်ဆို့")
chain.AddBlock("စတင်ပြီးနောက်တတိယပိတ်ဆို့")
_၊ block := range chain.blocks {
fmt.Printf(“ယခင် Hash- %x\n”၊ block.PrevHash)
fmt.Printf(“ဘလောက်ထဲကဒေတာ- %s\n”၊ block.Data)
fmt.Printf(“Hash: %x\n”၊ block.Hash)
}
}
- နောက်ဆုံးတွင်၊ ကျွန်ုပ်တို့သည် ပင်မလုပ်ဆောင်ချက်သို့ ရောက်ရှိသွားပါပြီ။ သင်တွေ့မြင်ရသည့်အတိုင်း ကျွန်ုပ်တို့သည် InitBlockChain() ဟုခေါ်ပြီး ၎င်းကို ကွင်းဆက်ပြောင်းလဲနိုင်သောပုံစံသို့ သတ်မှတ်ပေးထားပါသည်။
- ထို့နောက်၊ ကျွန်ုပ်တို့သည် chain.AddBlock မှတစ်ဆင့် ကွင်းဆက်သို့ ဘလောက်များကို ပေါင်းထည့်နေပြီး လိုအပ်သောဒေတာကို ကျွန်ုပ်တို့ဖြတ်သန်းပါသည်။
- ၎င်းကိုပြီးနောက်၊ ကျွန်ုပ်တို့သည် blockchain ကိုစစ်ဆေးရန် for loop တစ်ခုကို run သည်။ ထို့နောက် ဘလောက်တစ်ခုစီကို ခွဲထုတ်ပြီး ဘလောက်တစ်ခုစီအတွင်း အကွက်များကို ရိုက်နှိပ်ပါ။ ကျွန်ုပ်တို့က စာရိုက်ရုံပါပဲ-
fmt.Printf(“ယခင် Hash- %x\n”၊ block.PrevHash)
fmt.Printf(“ဘလောက်ထဲကဒေတာ- %s\n”၊ block.Data)
fmt.Printf(“Hash: %x\n”၊ block.Hash)
output:
အဲဒီတော့ အစီအစဉ်က အောင်မြင်တယ်လို့ ပြောလို့ရတယ်။ Golang ရှိ blockchain ၏သဘောတရားကိုသင်နားလည်နိုင်မည်ဟုမျှော်လင့်ပါသည်။ ဆက်လက်လေ့ကျင့်ရုံနဲ့ ရှုပ်ထွေးတဲ့ ပရောဂျက်တွေကို ကိုင်တွယ်နိုင်ပါလိမ့်မယ်။
သင်၏ crypto သည် အကောင်းဆုံးလုံခြုံရေးနှင့်ထိုက်တန်သည်။ တစ်ခုရယူပါ။ လယ်ဂျာ ဟာ့ဒ်ဝဲ ပိုက်ဆံအိတ် $79 သာ
အရင်းအမြစ်- https://coinfomania.com/build-a-blockchain-in-golang/