兄弟连区块链培训教程Go语言orm使用

合集下载

兄弟连Go语言区块链培训教程之以太坊源码详解3

很多人喜欢Go语言，其实是因为Go语言有其独特的语言属性在支撑着其在编程语言界的发展，今天兄弟连Go语言+区块链培训老师给大家介绍一下关于以太坊源码详解3，下面我们一起来看一下吧。

一、转账的概念和交易的基本流程用户输入转入的地址和金额系统用转账地址的私钥对交易进行签名(确保这笔交易是由发起交易的所有人) 对交易进行验证存入交易缓存池广播交易二、交易的数据type Transaction struct {data txdata // 交易数据// cacheshash atomic.Value // 交易哈希size atomic.Value // 交易大小from atomic.Value // 交易来源}type txdata struct {AccountNonce uint64 //发送者发起的交易的总数量Price, GasLimit *big.Int // gas价格与上线Recipient *common.Address `rlp:"nil"` // nil means cont ract creation // 接收者的地址，如果该地址为空，代表其是一个合约的创建者Amount *big.Int // 此次交易所转的以太币的数量Payload []byte // 其他数据V byte // signature // 交易签名数据R, S *big.Int // signature 交易签名数据}三、哈希type (Hash [hashLength]byte // 哈希值Address [addressLength]byte // 地址)func BytesToHash(b []byte) Hash {var h Hashh.SetBytes(b)return h}四、区块数据结构type Block struct {header *Header // 区块头uncles []*Header // 叔区块transactions Transactions // 交易receipts Receipts // 接收者// cacheshash atomic.Value // 哈希size atomic.Value // 区块大小// Td is used by package core to store the total difficulty// of the chain up to and including the block.Td *big.Int // 总的难度值// ReceivedAt is used by package eth to track block propaga tion time.ReceivedAt time.Time // 接收时间}五、区块头数据结构type Header struct {ParentHash common.Hash // Hash to the previous block 上一个区块哈希UncleHash common.Hash // Uncles of this block 叔区块的哈希Coinbase common.Address // The coin base address 矿工接收奖励的地址Root common.Hash // Block Trie state “State DB”的“state tired”的RLP的根节点的哈希值TxHash common.Hash // Tx sha “state db”中“state tir ed”的RLP根节点哈希值ReceiptHash common.Hash // Receipt sha “receipt tire”的R LP的根节点的哈希值Bloom Bloom // Bloom 布隆过滤器Difficulty *big.Int // Difficulty for the current block 区块难度Number *big.Int // The block number 区块号GasLimit *big.Int // Gas limit 理论上的gas上限GasUsed *big.Int // Gas used 区块内所有交易执行所产生的gas的总和Time uint64 // Creation time 区块创建时间Extra []byte // Extra dataMixDigest common.Hash // for quick difficulty verificatio nNonce BlockNonce // 随机数}六、创建新区块// NewBlock creates a new block. The input data is copied,// changes to header and to the field values will not affect the// block.//// The values of TxHash, UncleHash, ReceiptHash and Bloom in hea der// are ignored and set to values derived from the given txs, uncles// and receipts.func NewBlock(header *Header, txs []*Transaction, uncles []*Header, receipts []*Receipt) *Block {b := &Block{header: copyHeader(header), Td: new(big.Int)}// TODO: panic if len(txs) != len(receipts)if len(txs) == 0 {b.header.TxHash = emptyRootHash} else {b.header.TxHash = DeriveSha(Transactions(txs))b.transactions = make(Transactions, len(txs))copy(b.transactions, txs)}if len(receipts) == 0 {b.header.ReceiptHash = emptyRootHash} else {b.header.ReceiptHash = DeriveSha(Receipts(receipts))b.header.Bloom = CreateBloom(receipts)b.receipts = make([]*Receipt, len(receipts))copy(b.receipts, receipts)}if len(uncles) == 0 {b.header.UncleHash = emptyUncleHash} else {b.header.UncleHash = CalcUncleHash(uncles)b.uncles = make([]*Header, len(uncles))for i := range uncles {b.uncles[i] = copyHeader(uncles[i])}}return b}。

兄弟连区块链培训之Go语言基础教程自定义类型

兄弟连区块链培训之Go语言基础教程自定义类型综合市场上区块链培训周期来看，目前培训周期大体可分为短期和半年期。

而区块链作为一门新兴前沿且综合性强的学科技术，对于小白用户或是有基本了解的用户来说，仅凭数天的简单镀金就想在领域内有所建树，几乎是完全不可能实现的。

兄弟连教育建议，用户在考虑培训周期时要切实结合自身目前所掌握的区块链知识的多少、培训的目的是简单的认知提升还是借此高薪就业等等。

兄弟连Go全栈与区块链课程设置为5个半月共计22周的学习时长，由浅入深进行讲解，助力于小白用户向区块链工程师的转型。

可将类型分为命名和未命名两⼤大类。

命名类型包括bool、int、string 等，⽽而array、slice、map 等和具体元素类型、⻓长度等有关，属于未命名类型。

具有相同声明的未命名类型被视为同⼀一类型。

•具有相同基类型的指针。

•具有相同元素类型和⻓长度的array。

•具有相同元素类型的slice。

•具有相同键值类型的map。

•具有相同元素类型和传送⽅方向的channel。

•具有相同字段序列(字段名、类型、标签、顺序) 的匿名struct。

•签名相同(参数和返回值，不包括参数名称) 的function。

•⽅方法集相同(⽅方法名、⽅方法签名相同，和次序⽆无关) 的interface。

var a struct { x int `a` }var b struct { x int `ab` }// cannot use a (type struct { x int "a" }) as type struct { x int "ab" } in assignmentb = a可⽤用type 在全局或函数内定义新类型。

func main() {type bigint int64var x bigint = 100println(x)}新类型不是原类型的别名，除拥有相同数据存储结构外，它们之间没有任何关系，不会持有原类型任何信息。

兄弟连区块链教程Go语言基础连接MySQL数据库操作

兄弟连区块链教程Go语言基础连接MySQL数据库操作2018年时已过半，在今年的区块链热潮中，国内各家科技巨头均已粉墨登场，开始在这个新兴领域里抢占高地。

但在具体布局细节上，几大巨头又各有不同，从中亦可窥见它们各自对区块链的重视程度和期许方向。

兄弟连Go语言全栈与区块链技术培训课程是由清华、微软和谷歌名师历时半年时间研发出的独一无二的体系化课程。

课程涵盖9大学习阶段，及多个企业级项目实战和来自世界顶尖区块链比赛作品，并由以微软区块链最具价值专家尹成为代表的清华系区块链团队亲临授课，综合提升学员的职场竞争力。

（1）导入数据库驱动import (_"/doc/33994403.html,/Go-SQL-Driver/MySQL")这里使用_ 的意思是引入后面的包名而不直接使用这个包中定义的函数，变量等资源。

若出现无法导入的情况，我们可以使用以下方式解决（以window系统为例）windows+R 打开cmd，输入go get /doc/33994403.html,/vmihailenco/redis , 回车之后会自动下载项目到GOPATH中的src目录下，然后刷新IDE。

（2）数据库连接使用sql.Open 用来打开一个注册过的数据库驱动，这里有几种连接方式，如下所示，一般我们选用第二种方式user@unix(/path/to/socket)/dbname?charset=utf8user:password@tcp(localhost:3306)/dbname?charset=utf8user:password@/dbnameuser:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname（3）增删改查操作package mainimport ("database/sql""fmt"_"/doc/33994403.html,/Go-SQL-Driver/MySQL")var(DBHostsIp = "localhost:3306"DBUserName = "root"DBPassWord = "123456"DBName = "localmysql")func main(){//连接至数据库db,err := sql.Open("mysql", DBUserName+":"+DBPassWord+"@tcp("+DBHostsIp+")/"+DBN ame)CheckErr(err)insert(db)//关闭数据库连接db.Close()}//插入demofunc insert(db *sql.DB) {//准备插入操作stmt,err := db.Prepare("INSERT user (user_name,user_age,user_sex) values (?,?,?)")CheckErr(err)//执行插入操作res,err := stmt.Exec("limao",26,2)CheckErr(err)//返回最近的自增主键idid,err := /doc/33994403.html,stInsertId() fmt.Println("LastInsertId: ",id)}//查询demofunc query(db *sql.DB) {//rows：返回查询操作的结果集rows,err := db.Query("SELECT * FROM user")CheckErr(err)//第一步：接收在数据库表查询到的字段名，返回的是一个string 数组切片columns, _ := rows.Columns() // columns: [user_id user_name user_age user_sex]//根据string数组切片的长度构造scanArgs、values两个数组，scanArgs的每个值指向values相应值的地址scanArgs := make([]interface{}, len(columns))values := make([]interface{}, len(columns))for i := range values {scanArgs[i] = &values[i]}for rows.Next() {//将查询到的字段名的地址复制到scanArgs数组中err = rows.Scan(scanArgs...)CheckErr(err)//将行数据保存到record字典record := make(map[string]string)for i, col := range values {if col != nil {//字段名= 字段信息record[columns[i]] = string(col.([]byte))}}fmt.Println(record)}}//更新demofunc update(db *sql.DB) {//准备更新操作stmt1,err := db.Prepare("UPDATE user SET user_age=?,user_sex=? WHERE user_id=?") CheckErr(err) //执行更新操作res1, err := stmt1.Exec(21, 2, 1)CheckErr(err)//查询更新多少条信息num, err := res1.RowsAffected()CheckErr(err)fmt.Println(num)}//删除demofunc remove(db *sql.DB) {//准备删除操作stmt, err := db.Prepare(`DELETE FROM user WHERE user_id=?`)CheckErr(err)//执行删除操作res, err := stmt.Exec(1)CheckErr(err)//查询删除多少条信息num, err := res.RowsAffected()CheckErr(err)fmt.Println(num)}//检查错误信息func CheckErr(err error) {if err != nil {panic(err)}}总结：db.Prepare()函数用来返回准备要执行的sql操作，然后返回准备完毕的执行状态。

兄弟连区块链培训分享Go语言范围(Range)

兄弟连区块链培训分享Go语言范围(Range)兄弟连教育建议，用户在考虑培训周期时要切实结合自身目前所掌握的区块链知识的多少、培训的目的是简单的认知提升还是借此高薪就业等等。

兄弟连Go全栈与区块链培训课程设置为5个半月共计22周的学习时长，由浅入深进行讲解，助力于小白用户向区块链工程师的转型。

课程体系设计架构包括了区块链的基础语言Go语言、区块链后端技术体系、区块链公链、区块链分布式应用开发等内容讲解，以及到最后的面试指导和项目实战。

课程由清华微软谷歌名师团队精心打造，历时半年时间共同研发而出。

Go 语言中range 关键字用于for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。

在数组和切片中它返回元素的索引和索引对应的值，在集合中返回key-value 对的key 值。

实例package mainimport "fmt"func main() {//这是我们使用range去求一个slice的和。

使用数组跟这个很类似nums := []int{2, 3, 4}sum := 0for _, num := range nums {sum += num}fmt.Println("sum:", sum)//在数组上使用range将传入index和值两个变量。

上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。

有时侯我们确实需要知道它的索引。

for i, num := range nums {if num == 3 {fmt.Println("index:", i)}}//range也可以用在map的键值对上。

kvs := map[string]string{"a": "apple", "b": "banana"}for k, v := range kvs {fmt.Printf("%s -> %s\n", k, v)}//range也可以用来枚举Unicode字符串。

兄弟连Go语言区块链培训教程之以太坊源码详解5

兄弟连Go语言区块链培训教程之以太坊源码详解5很多人喜欢Go语言，其实是因为Go语言有其独特的语言属性在支撑着其在编程语言界的发展，今天兄弟连Go语言+区块链培训老师给大家介绍一下关于以太坊源码详解，下面我们一起来看一下吧。

交易步骤发起交易：制定目标地址和交易金额，以及gas和gaslimit交易签名：使用账户的私钥对交易进行签名提交交易：把交易添加到交易缓冲池中(会先对签名进行验证)广播交易：通知EVM执行，同时把交易广播到其他节点具体分析1、发起交易func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args SendTxArgs) (common.Hash, error) {// Look up the wallet containing the requested signeraccount := accounts.Account{Address: args.From}// 得到钱包wallet, err := s.b.AccountManager().Find(account)if err != nil {return common.Hash{}, err}if args.Nonce == nil {// Hold the addresse's mutex around signing to prevent concurrent assignment of// the same nonce to multiple accounts.s.nonceLock.LockAddr(args.From)defer s.nonceLock.UnlockAddr(args.From)}// Set some sanity defaults and terminate on failureif err := args.setDefaults(ctx, s.b); err != nil {return common.Hash{}, err}// Assemble the transaction and sign with the wallettx := args.toTransaction()// 创建交易var chainID *big.Intif config := s.b.ChainConfig(); config.IsEIP155(s.b.CurrentBlock().Number()) {chainID = config.ChainID}signed, err := wallet.SignTx(account, tx, chainID) // 对交易签名(接口函数)if err != nil {return common.Hash{}, err}return submitTransaction(ctx, s.b, signed) // 提交交易(到内存池中) }2、创建交易func (args *SendTxArgs) toTransaction() *types.Transaction {var input []byteif args.Data != nil {input = *args.Data} else if args.Input != nil {input = *args.Input}if args.To == nil {return types.NewContractCreation(uint64(*args.Nonce), (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input)}// 调用创建交易函数return types.NewTransaction(uint64(*args.Nonce), *args.To, (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input)}3、发送的交易结构type SendTxArgs struct {From common.Address `json:"from"`To *common.Address `json:"to"`Gas *hexutil.Uint64 `json:"gas"`GasPrice *hexutil.Big `json:"gasPrice"`Value *hexutil.Big `json:"value"`Nonce *hexutil.Uint64 `json:"nonce"`// We accept "data" and "input" for backwards-compatibility reasons. "input" is the// newer name and should be preferred by clients.Data *hexutil.Bytes `json:"data"`Input *hexutil.Bytes `json:"input"`}4、新建交易的内部实现func newTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction {if len(data) > 0 {data = common.CopyBytes(data)}// 交易结构d := txdata{AccountNonce: nonce,Recipient: to,Payload: data,Amount: new(big.Int),GasLimit: gasLimit,Price: new(big.Int),V: new(big.Int),R: new(big.Int),S: new(big.Int),}if amount != nil {d.Amount.Set(amount)}if gasPrice != nil {d.Price.Set(gasPrice)}return &Transaction{data: d}}5、交易签名func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) {if args.Gas == nil {return nil, fmt.Errorf("gas not specified")}if args.GasPrice == nil {return nil, fmt.Errorf("gasPrice not specified")}if args.Nonce == nil {return nil, fmt.Errorf("nonce not specified")}if err := args.setDefaults(ctx, s.b); err != nil {return nil, err}tx, err := s.sign(args.From, args.toTransaction())if err != nil {return nil, err}data, err := rlp.EncodeToBytes(tx)if err != nil {return nil, err}return &SignTransactionResult{data, tx}, nil}// sign is a helper function that signs a transaction with the private key of the given address.func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) {// Look up the wallet containing the requested signeraccount := accounts.Account{Address: addr}wallet, err := s.b.AccountManager().Find(account)if err != nil {return nil, err}// Request the wallet to sign the transactionvar chainID *big.Intif config := s.b.ChainConfig(); config.IsEIP155(s.b.CurrentBlock().Number()) {chainID = config.ChainID}return wallet.SignTx(account, tx, chainID)}6、最终完成交易签名func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {h := s.Hash(tx)sig, err := crypto.Sign(h[:], prv)if err != nil {return nil, err}return tx.WithSignature(s, sig)}7、具体步骤生成哈希根据哈希值和私钥生成签名把签名数据填充到交易实例中8、提交交易到内存池中func submitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (common.Hash, error) {if err := b.SendTx(ctx, tx); err != nil {return common.Hash{}, err}if tx.To() == nil {signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number())from, err := types.Sender(signer, tx)if err != nil {return common.Hash{}, err}addr := crypto.CreateAddress(from, tx.Nonce())("Submitted contract creation", "fullhash", tx.Hash().Hex(), "contract", addr.Hex())} else {("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To()) }return tx.Hash(), nil //返回交易的哈希}9、交易缓存池的结构体type TxPool struct {config TxPoolConfigchainconfig *params.ChainConfigchain blockChaingasPrice *big.InttxFeed event.Feedscope event.SubscriptionScopechainHeadCh chan ChainHeadEventchainHeadSub event.Subscriptionsigner types.Signermu sync.RWMutexcurrentState *state.StateDB // Current state in the blockchain headpendingState *state.ManagedState // Pending state tracking virtual noncescurrentMaxGas uint64 // Current gas limit for transaction capslocals *accountSet // Set of local transaction to exempt from eviction rulesjournal *txJournal // Journal of local transaction to back up to diskpending map[common.Address]*txList // All currently processable transactions 当前等待处理的交易queue map[common.Address]*txList // Queued but non-processable transactionsbeats map[common.Address]time.Time // Last heartbeat from each known accountall *txLookup // All transactions to allow lookups 所有的交易列表priced *txPricedList // All transactions sorted by price // 通过gas 价格进行排序的交易列表,如果交易的gas price一样则按照nonce值从小到大排列wg sync.WaitGroup // for shutdown synchomestead bool}10、默认的交易池配置var DefaultTxPoolConfig = TxPoolConfig{Journal: "transactions.rlp",Rejournal: time.Hour,PriceLimit: 1,PriceBump: 10,AccountSlots: 16, pending中每个账户存储的交易阈值GlobalSlots: 4096, // 列表的最大长度AccountQueue: 64, // queue中每个账户允许存储的最大交易树GlobalQueue: 1024,Lifetime: 3 * time.Hour,}11、提交交易的内部调用func (b *EthAPIBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error { return b.eth.txPool.AddLocal(signedTx)}12、添加到交易池中func (pool *TxPool) addTx(tx *types.Transaction, local bool) error {pool.mu.Lock()defer pool.mu.Unlock()// Try to inject the transaction and update any statereplace, err := pool.add(tx, local) // 判断是否应该把当前交易加入到交易列表中if err != nil {return err}// If we added a new transaction, run promotion checks and returnif !replace {from, _ := types.Sender(pool.signer, tx) // already validatedpool.promoteExecutables([]common.Address{from}) // 选区一部分交易、放到pending中去}return nil}13、add 内部实现func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {// If the transaction is already known, discard it// 判断交易是否已经存在、有就直接退出hash := tx.Hash()if pool.all.Get(hash) != nil {log.Trace("Discarding already known transaction", "hash", hash)return false, fmt.Errorf("known transaction: %x", hash)}// If the transaction fails basic validation, discard it// 如果校验交易有效性检查不通过，退出if err := pool.validateTx(tx, local); err != nil {log.Trace("Discarding invalid transaction", "hash", hash, "err", err)invalidTxCounter.Inc(1)return false, err}// If the transaction pool is full, discard underpriced transactions 如果交易池满了、找出一些价格比较低的推掉if uint64(pool.all.Count()) >= pool.config.GlobalSlots+pool.config.GlobalQueue { // If the new transaction is underpriced, don't accept itif !local && pool.priced.Underpriced(tx, pool.locals) {log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())underpricedTxCounter.Inc(1)return false, ErrUnderpriced}// New transaction is better than our worse ones, make room for itdrop :=pool.priced.Discard(pool.all.Count()-int(pool.config.GlobalSlots+pool.config.GlobalQueue-1), pool.locals)for _, tx := range drop {log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice())underpricedTxCounter.Inc(1)pool.removeTx(tx.Hash(), false)}}// If the transaction is replacing an already pending one, do directlyfrom, _ := types.Sender(pool.signer, tx) // already validatedif list := pool.pending[from]; list != nil && list.Overlaps(tx) {// Nonce already pending, check if required price bump is metinserted, old := list.Add(tx, pool.config.PriceBump)if !inserted {pendingDiscardCounter.Inc(1)return false, ErrReplaceUnderpriced}// New transaction is better, replace old oneif old != nil {pool.all.Remove(old.Hash())pool.priced.Removed()pendingReplaceCounter.Inc(1)}pool.all.Add(tx)pool.priced.Put(tx)pool.journalTx(from, tx)log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())// We've directly injected a replacement transaction, notify subsystemsgo pool.txFeed.Send(NewTxsEvent{types.Transactions{tx}})return old != nil, nil}// New transaction isn't replacing a pending one, push into queue 把当前交易加入到队列里面去replace, err := pool.enqueueTx(hash, tx)if err != nil {return false, err}// Mark local addresses and journal local transactionsif local {pool.locals.add(from)}pool.journalTx(from, tx)log.Trace("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To())return replace, nil}14、交易有效性检查func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {// Heuristic limit, reject transactions over 32KB to prevent DOS attacksif tx.Size() > 32*1024 {return ErrOversizedData}// Transactions can't be negative. This may never happen using RLP decoded// transactions but may occur if you create a transaction using the RPC.if tx.Value().Sign() < 0 {return ErrNegativeValue}// Ensure the transaction doesn't exceed the current block limit gas.if pool.currentMaxGas < tx.Gas() {return ErrGasLimit}// Make sure the transaction is signed properlyfrom, err := types.Sender(pool.signer, tx)if err != nil {return ErrInvalidSender}// Drop non-local transactions under our own minimal accepted gas pricelocal = local || pool.locals.contains(from) // account may be local even if the transaction arrived from the networkif !local && pool.gasPrice.Cmp(tx.GasPrice()) > 0 {return ErrUnderpriced}// Ensure the transaction adheres to nonce orderingif pool.currentState.GetNonce(from) > tx.Nonce() {return ErrNonceTooLow}// Transactor should have enough funds to cover the costs// cost == V + GP * GLif pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {return ErrInsufficientFunds}intrGas, err := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead)if err != nil {return err}if tx.Gas() < intrGas {return ErrIntrinsicGas}return nil}15、具体步骤：1：数据量必须小于32KB2：交易金额必须非负3：交易gas limit必须低于block 的gas limit4：签名必须有效，能够解析出发送者的地址5：交易的gas price 必须高于最低的gas price6：账户余额必须大于交易金额加上交易燃料费7：gas limit必须大于所需的gas 水平8：交易的nonce值必须高于链上的nonce值，如果低于则说明该交易已经被打包过了。

兄弟连区Go语言+区块链技术培训以太坊源码分析(19)core-blockchain分析

兄弟连区Go语言+区块链技术培训以太坊源码分析(19)cor e-blockchain分析从测试案例来看,blockchain的主要功能点有下面几点.1. import.2. GetLastBlock的功能.3. 如果有多条区块链,可以选取其中难度最大的一条作为规范的区块链.4. BadHashes 可以手工禁止接受一些区块的hash值.在blocks.go里面.5. 如果新配置了BadHashes. 那么区块启动的时候会自动禁止并进入有效状态.6. 错误的nonce会被拒绝.7. 支持Fast importing.8. Light vs Fast vs Full processing 在处理区块头上面的效果相等.可以看到blockchain的主要功能是维护区块链的状态, 包括区块的验证,插入和状态查询.名词解释:什么是规范的区块链因为在区块的创建过程中,可能在短时间内产生一些分叉, 在我们的数据库里面记录的其实是一颗区块树.我们会认为其中总难度最高的一条路径认为是我们的规范的区块链. 这样有很多区块虽然也能形成区块链,但是不是规范的区块链.数据库结构:区块的hash值和区块头的hash值是同样的么。

所谓的区块的Hash值其实就是Header 的区块值。

// key -> value// + 代表连接"LastHeader" 最新的区块头HeaderChain中使用"LastBlock" 最新的区块头BlockChain 中使用"LastFast" 最新的快速同步的区块头"h"+num+"n" -> hash 用来存储规范的区块链的高度和区块头的hash值"h" + num + hash -> header 高度+hash值-> 区块头"h" + num + hash + "t" -> td 高度+hash值-> 总难度"H" + hash -> num 区块体hash -> 高度"b" + num + hash -> block body 高度+hash值-> 区块体"r" + num + hash -> block receipts 高度+ hash值-> 区块收据"l" + hash -> transaction/receipt lookup metadatakey | value|说明|插入|删除|---- | --- |---------------|-----------|-----------|"LastHeader" | hash | 最新的区块头HeaderChain中使用|当区块被认为是当前最新的一个规范的区块链头|当有了更新的区块链头或者是分叉的兄弟区块链替代了它"LastBlock" | hash | 最新的区块头BlockChain中使用|当区块被认为是当前最新的一个规范的区块链头|当有了更新的区块链头或者是分叉的兄弟区块链替代了它"LastFast" | hash | 最新的区块头BlockChain中使用|当区块被认为是当前最新的规范的区块链头|当有了更新的区块链头或者是分叉的兄弟区块链替代了它"h"+num+"n"|hash|用来存储规范的区块链的高度和区块头的hash值在HeaderChain中使用|当区块在规范的区块链中|当区块不在规范的区块链中"h" + num + hash + "t"|td|总难度|WriteBlockAndState当验证并执行完一个区块之后(不管是不是规范的)|SetHead方法会调用。

兄弟连区Go语言+区块链技术培训以太坊源码分析(21)chain_indexer 区块链索引

兄弟连区Go语言+区块链技术培训以太坊源码分析(21)chai n_indexer 区块链索引## chain_indexer 区块链索引chain_indexer.go 源码解析chain_indexer 顾名思义，就是用来给区块链创建索引的功能。

之前在eth协议的时候，介绍过BloomIndexer的功能，其实BloomIndexer是chain_indexer的一个特殊的实现，可以理解为派生类，主要的功能其实实在chain_indexer这里面实现的。

虽说是派生类，但是chain_indexer其实就只被BloomIndexer使用。

也就是给区块链的布隆过滤器创建了索引，以便快速的响应用户的日志搜索功能。

下面就来分析这部分的代码。

### 数据结构// ChainIndexerBackend defines the methods needed to process chain segments in// the background and write the segment results into the database. These can be// used to create filter blooms or CHTs.// ChainIndexerBackend定义了处理区块链片段的方法，并把处理结果写入数据库。

这些可以用来创建布隆过滤器或者CHTs.// BloomIndexer 其实就是实现了这个接口 ChainIndexerBackend 这里的CHTs 不知道是什么东西。

type ChainIndexerBackend interface {// Reset initiates the processing of a new chain segment, poten tially terminating// any partially completed operations (in case of a reorg).// Reset 方法用来初始化一个新的区块链片段，可能会终止任何没有完成的操作。

兄弟连区Go语言+区块链技术培训以太坊源码分析(18)以太坊交易执行分析

兄弟连区Go语言+区块链技术培训以太坊源码分析(18)以太坊交易执行分析#以太坊交易执行分析在这里，将其整体串起来，从state_processor.Process函数开始，归纳一下其所作的处理。

##1 ProcessProcess 根据以太坊规则运行交易信息来对statedb进行状态改变，以及奖励挖矿者或者是其他的叔父节点。

Process返回执行过程中累计的收据和日志，并返回过程中使用的Gas。

如果由于Gas不足而导致任何交易执行失败，将返回错误。

**处理逻辑：**~~~1. 定义及初始化收据、耗费的gas、区块头、日志、gas池等变量；2. 如果是DAO事件硬分叉相关的处理，则调用misc.ApplyDAOHardFork(statedb)执行处理；3. 对区块中的每一个交易，进行迭代处理；处理逻辑：a. 对当前交易做预处理，设置交易的hash、索引、区块hash，供EVM发布新的状态日志使用；b. 执行ApplyTransaction，获取收据；c. 若上一步出错，中断整个Process，返回错误；d. 若正常，累积记录收据及日志。

循环进入下一个交易的处理。

4. 调用共识模块做Finalize处理；5. 返回所有的收据、日志、总共使用的gas。

~~~##2 ApplyTransaction(1.3.b )ApplyTransaction尝试将交易应用于给定的状态数据库，并使用输入参数作为其环境。

它返回交易的收据，使用的Gas和错误，如果交易失败，表明块是无效的。

**处理逻辑：**~~~1. 将types.Transaction结构变量转为core.Message对象；这过程中会对发送者做签名验证，并获得发送者的地址缓存起来；2. 创建新的上下文（Context），此上下文将在EVM 环境（EVM environment）中使用；上下文中包含msg，区块头、区块指针、作者（挖矿者、获益者）；3. 创建新的EVM environment，其中包括了交易相关的所有信息以及调用机制；4. ApplyMessage，将交易应用于当前的状态中，也就是执行状态转换，新的状态包含在环境对象中；得到执行结果以及花费的gas；5. 判断是否分叉情况（`config.IsByzantium(header.Number)` ），如果不是，获取当前的statedb的状态树根哈希；6. 创建一个收据, 用来存储中间状态的root, 以及交易使用的gas；7. 如果是创建合约的交易，那么我们把创建地址存储到收据里面；8. 拿到所有的日志并创建日志的布隆过滤器；返回。

兄弟连区块链培训Go语言(一)Go环境搭建

兄弟连区块链培训Go语言（一）Go环境搭建随着区块链引发的“颠覆风暴”，大量区块链培训机构应运而生。

但在鱼龙混杂的培训圈内，要想找到真正符合标准的课程体系与专属区块链领域的专业授课讲师简直是沧海一粟。

兄弟连教育指出，是时候做出行动改变并颠覆传统培训机构运营思维，并提醒大众用户，应理性选择区块链培训机构。

安装GoGo语言的优劣，这里就不介绍了，下面直接讲Go 的安装：安装包下载完成之后，安装过程很简单，傻瓜式下一步到底就好了。

Go 环境变量安装go 的时候，安装程序会自动把相关目录写到系统环境。

但是如果是zip 的安装，需要自己手动添加。

主要配置以下几个：GOROOT：Go 安装后的根目录（例如：D:\Go），安装过程中会由安装程序自动写入系统环境变量中。

GOBIN：Go 的二进制文件存放目录（%GOROOT%\bin）PATH：需要将%GOBIN% 加在PATH 变量的最后，方便在命令行下运行。

当环境变量都配置完成之后，Go 就已经安装完毕了。

打开命令行，运行go 命令，就可以看到如下的提示了。

Go 工作空间GOPATH : Go 的工作空间，就是我们的开发和依赖包的目录（例如：我的是D:\Go_Path\go），此目录需要手动配置到系统环境变量GOPATH 工作空间是一个目录层次结构，其根目录包含三个子目录：src：包含Go 源文件，注意：你自己创建依赖的package，也要放到GOPATH 目录下，这样才能够被引用到。

pkg：包含包对象，编译好的库文件bin：包含可执行命令注意：1. 需要将GOPATH 路径，手动写入到系统环境变量。

2. 不要把GOPATH 设置成Go 的安装路径3. 你自己创建依赖的package，也要放到GOPATH 目录下，这样才能够被引用到。

配置好之后，通过go env 命令来查看go环境是否配置正确：Hello World现在，一起来Hello World 吧！package mainimport ("fmt")func main() {fmt.Println("Hello World!")}将上面的程序保存成helloworld.go，然后在命令行中执行：go run helloworld.go。

兄弟连区块链培训分享Go语言中使用leveldb

兄弟连区块链培训分享Go语言中使用leveldb2018年第一季度，区块链相关人才的招聘需求已达到2017年同期的9.7倍，发布区块链相关岗位的公司数量同比增长4.6倍。

兄弟连教育Go全栈与区块链培训课程是由清华、微软和谷歌名师历时半年时间研发出的独一无二的体系化课程。

leveldb是一个很强悍的kv数据库，自然，我也希望能在go中使用。

使用levigo，需要编译安装leveldb，如果需要压缩支持还需要编译snappy，为了简单，我写了一个构件脚本，如下：#设置实际的snappy以及leveldb源码地址SNAPPY_SRC=./snappyLEVELDB_SRC=./leveldbSNAPPY_DIR=/usr/local/snappyLEVELDB_DIR=/usr/local/leveldbif [ ! -f $SNAPPY_DIR/lib/libsnappy.a ]; then(cd $SNAPPY_SRC && \./configure --prefix=$SNAPPY_DIR && \make && \make install)elseecho "skip install snappy"fiif [ ! -f $LEVELDB_DIR/lib/libleveldb.a ]; then(cd $LEVELDB_SRC && \echo "echo \"PLATFORM_CFLAGS+=-I$SNAPPY_DIR/include\">> build_config.mk">> build_detect_platform &&echo "echo \"PLATFORM_CXXFLAGS+=-I$SNAPPY_DIR/include\">> build_config.mk">> build_detect_platform &&echo "echo \"PLATFORM_LDFLAGS+=-L $SNAPPY_DIR/lib -lsnappy\">> build_config.mk">> build_detect_platform &&make SNAPPY=1 && \make && \mkdir -p $LEVELDB_DIR/include/leveldb && \install include/leveldb/*.h $LEVELDB_DIR/include/leveldb && \mkdir -p $LEVELDB_DIR/lib && \cp -af libleveldb.* $LEVELDB_DIR/lib)elseecho "skip install leveldb"fifunction add_path(){# $1 path variable# $2 path to addif [ -d "$2" ] && [[ ":$1:" != *":$2:"* ]]; thenecho "$1:$2"elseecho "$1"fi}export CGO_CFLAGS="-I$LEVELDB_DIR/include -I$SNAPPY_DIR/include"export CGO_LDFLAGS="-L$LEVELDB_DIR/lib -L$SNAPPY_DIR/lib -lsnappy"export LD_LIBRARY_PATH=$(add_path $LD_LIBRARY_PATH $SNAPPY_DIR/lib)export LD_LIBRARY_PATH=$(add_path $LD_LIBRARY_PATH $LEVELDB_DIR/lib)go get /jmhodges/levigo对于leveldb在go里面的使用，levigo做了很好的封装，但是有一点我不怎么习惯，在leveldb中，对于read和write的操作，都需要传入一个Option的东西，这玩意大多数时候都是一个默认Option对象，没必要每次在go里面进行创建删除。

兄弟连Go语言+区块链技术培训以太坊源码分析(50)p2p-udp.go源码分析

兄弟连Go语言+区块链技术培训以太坊源码分析(50）p2p-udp.go源码分析p2p的网络发现协议使用了Kademlia protocol 来处理网络的节点发现。

节点查找和节点更新。

Kademlia protocol使用了UDP协议来进行网络通信。

阅读这部分的代码建议先看看references里面的Kademlia协议简介来看看什么是Kade mlia协议。

首先看看数据结构。

网络传输了4种数据包(UDP协议是基于报文的协议。

传输的是一个一个数据包)，分别是ping,pong,findnode和neighbors。

下面分别定义了4种报文的格式。

// RPC packet typesconst (pingPacket = iota + 1 // zero is 'reserved'pongPacketfindnodePacketneighborsPacket)// RPC request structurestype (ping struct {Version uint //协议版本From, To rpcEndpoint //源IP地址目的IP地址Expiration uint64 //超时时间// Ignore additional fields (for forward compatibility).//可以忽略的字段。

为了向前兼容Rest []rlp.RawValue `rlp:"tail"`}// pong is the reply to ping.// ping包的回应pong struct {// This field should mirror the UDP envelope address// of the ping packet, which provides a way to discover the // the external address (after NAT).// 目的IP地址To rpcEndpoint// 说明这个pong包是回应那个ping包的。

兄弟连区Go语言+区块链技术培训以太坊源码分析(11)eth目前的共识算法pow的整理

兄弟连区块链技术培训以太坊源码分析(11)eth目前的共识算法pow的整理### eth目前的共识算法pow的整理##### 涉及的代码子包主要有consensus,miner,core,geth```/consensus 共识算法consensus.go1. Prepare方法2. CalcDifficulty方法：计算工作量3. AccumulateRewards方法：计算每个块的出块奖励4. VerifySeal方法：校验pow的工作量难度是否符合要求，返回nil则通过5. verifyHeader方法：校验区块头是否符合共识规则```/miner 挖矿work.gocommitNewWork():提交新的块，新的交易,从交易池中获取未打包的交易，然后提交交易,进行打包__核心代码__:```// Create the current work task and check any fork transitions neededwork := self.currentif self.config.DAOForkSupport && self.config.DAOForkBlock != nil && sel f.config.DAOForkBlock.Cmp(header.Number) == 0 {misc.ApplyDAOHardFork(work.state)}pending, err := self.eth.TxPool().Pending()if err != nil {log.Error("Failed to fetch pending transactions", "err", err)return}txs := types.NewTransactionsByPriceAndNonce(self.current.signer, pendi ng)mitTransactions(self.mux, txs, self.chain, self.coinbase)``````eth/handler.goNewProtocolManager --> verifyHeader --> VerifySeal```__整条链的运行,打包交易,出块的流程__```/cmd/geth/main.go/mainmakeFullNode-->RegisterEthService-->eth.New-->NewProtocolManager --> verifyHeader --> VerifySeal```##### eth的共识算法pow调用栈详解###### 核心的逻辑需要从/eth/handler.go/NewProtocolManager方法下开始,关键代码:```manager.downloader = downloader.New(mode, chaindb, manager.eventMu x, blockchain, nil, manager.removePeer)validator := func(header *types.Header) error {return engine.VerifyHeader(blockchain, header, true)}heighter := func() uint64 {return blockchain.CurrentBlock().NumberU64()}inserter := func(blocks types.Blocks) (int, error) {// If fast sync is running, deny importing weird blocksif atomic.LoadUint32(&manager.fastSync) == 1 {log.Warn("Discarded bad propagated block", "number", blocks[0].Nu mber(), "hash", blocks[0].Hash())return 0, nil}atomic.StoreUint32(&manager.acceptTxs, 1) // Mark initial sync done on any fetcher importreturn manager.blockchain.InsertChain(blocks)}manager.fetcher = fetcher.New(blockchain.GetBlockByHash, validator, m anager.BroadcastBlock, heighter, inserter, manager.removePeer)return manager, nil```###### 该方法中生成了一个校验区块头部的对象`validator`###### 让我们继续跟进`engine.VerifyHeader(blockchain, header, true)`方法: ```// VerifyHeader checks whether a header conforms to the consensus rules of the// stock Ethereum ethash engine.func (ethash *Ethash) VerifyHeader(chain consensus.ChainReader, header *types.Header, seal bool) error {// If we're running a full engine faking, accept any input as validif ethash.fakeFull {return nil}// Short circuit if the header is known, or it's parent notnumber := header.Number.Uint64()if chain.GetHeader(header.Hash(), number) != nil {return nil}parent := chain.GetHeader(header.ParentHash, number-1)if parent == nil {return consensus.ErrUnknownAncestor}// Sanity checks passed, do a proper verificationreturn ethash.verifyHeader(chain, header, parent, false, seal)}```###### 首先看第一个if,它的逻辑判断是如果为true,那么就关闭所有的共识规则校验,紧跟着两个if判断是只要该block的header的hash和number或者上一个header的hash和number存在链上,那么它header的共识规则校验就通过,如果都不通过,那么该区块校验失败跑出错误.如果走到最后一个return,那么就需要做一些其他额外验证```// verifyHeader checks whether a header conforms to the consensus rules of the// stock Ethereum ethash engine.// See YP section 4.3.4. "Block Header Validity"func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error {// Ensure that the header's extra-data section is of a reasonable size if uint64(len(header.Extra)) > params.MaximumExtraDataSize {return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), pa rams.MaximumExtraDataSize)}// Verify the header's timestampif uncle {if header.Time.Cmp(math.MaxBig256) > 0 {return errLargeBlockTime}} else {if header.Time.Cmp(big.NewInt(time.Now().Unix())) > 0 {return consensus.ErrFutureBlock}}if header.Time.Cmp(parent.Time) <= 0 {return errZeroBlockTime}// Verify the block's difficulty based in it's timestamp and parent's difficul tyexpected := CalcDifficulty(chain.Config(), header.Time.Uint64(), parent) if expected.Cmp(header.Difficulty) != 0 {return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficult y, expected)}// Verify that the gas limit is <= 2^63-1if header.GasLimit.Cmp(math.MaxBig63) > 0 {return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimi t, math.MaxBig63)}// Verify that the gasUsed is <= gasLimitif header.GasUsed.Cmp(header.GasLimit) > 0 {return fmt.Errorf("invalid gasUsed: have %v, gasLimit %v", header.Ga sUsed, header.GasLimit)}// Verify that the gas limit remains within allowed boundsdiff := new(big.Int).Set(parent.GasLimit)diff = diff.Sub(diff, header.GasLimit)diff.Abs(diff)limit := new(big.Int).Set(parent.GasLimit)limit = limit.Div(limit, params.GasLimitBoundDivisor)if diff.Cmp(limit) >= 0 || header.GasLimit.Cmp(params.MinGasLimit) < 0 { return fmt.Errorf("invalid gas limit: have %v, want %v += %v", header. GasLimit, parent.GasLimit, limit)}// Verify that the block number is parent's +1if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.N ewInt(1)) != 0 {return consensus.ErrInvalidNumber}// Verify the engine specific seal securing the blockif seal {if err := ethash.VerifySeal(chain, header); err != nil {return err}}// If all checks passed, validate any special fields for hard forksif err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil {return err}if err := misc.VerifyForkHashes(chain.Config(), header, uncle); err != nil { return err}return nil}```###### 该方法会去校验该区块头中的extra数据是不是比约定的参数最大值还大,如果超过,则返回错误,其次会去判断该区块是不是一个uncle区块,如果head er的时间戳不符合规则则返回错误,然后根据链的配置,header的时间戳以及上一个区块计算中本次区块期待的难度,如果header的难度和期待的不一致,或he ader的gasLimit比最大数字还大,或已用的gas超过gasLimit,则返回错误.如果g asLimit超过预定的最大值或最小值,或header的number减去上一个block的h eader的number不为1,则返回错误.`seal`为true,则会去校验该区块是否符合pow的工作量证明的要求(`verifySeal`方法),因为私有链一般是不需要pow.最后两个if是去判断区块是否具有正确的hash,防止用户在不同的链上,以及校验块头的额外数据字段是否符合DAO硬叉规则###### uncle block:__eth允许旷工在挖到一个块的同时包含一组uncle block列表,主要有两个作用: __1. 由于网络传播的延迟原因,通过奖励那些由于不是链组成区块部分而产生陈旧或孤立区块的旷工,从而减少集权激励2. 通过增加在主链上的工作量来增加链条的安全性(在工作中,少浪费工作在陈旧的块上)eth的pow核心代码:```// CalcDifficulty is the difficulty adjustment algorithm. It returns// the difficulty that a new block should have when created at time// given the parent block's time and difficulty.// TODO (karalabe): Move the chain maker into this package and make th is private!func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.H eader) *big.Int {next := new(big.Int).Add(parent.Number, big1)switch {case config.IsByzantium(next):return calcDifficultyByzantium(time, parent)case config.IsHomestead(next):return calcDifficultyHomestead(time, parent)default:return calcDifficultyFrontier(time, parent)}}```###### 该方法的第一个`case`是根据拜占庭规则去计算新块应该具有的难度,第二个`case`是根据宅基地规则去计算新块应该具有的难度,第三个`case`是根据边界规则去计算难度#### pow计算生成新块代码解析__/consensus/seal.go/seal__```// Seal implements consensus.Engine, attempting to find a nonce that sati sfies// the block's difficulty requirements.func (ethash *Ethash) Seal(chain consensus.ChainReader, block *types.Blo ck, stop <-chan struct{}) (*types.Block, error) {// If we're running a fake PoW, simply return a 0 nonce immediatelyif ethash.fakeMode {header := block.Header()header.Nonce, header.MixDigest = types.BlockNonce{}, common.Hash {}return block.WithSeal(header), nil}// If we're running a shared PoW, delegate sealing to itif ethash.shared != nil {return ethash.shared.Seal(chain, block, stop)}// Create a runner and the multiple search threads it directsabort := make(chan struct{})found := make(chan *types.Block)ethash.lock.Lock()threads := ethash.threadsif ethash.rand == nil {seed, err := crand.Int(crand.Reader, big.NewInt(math.MaxInt64))if err != nil {ethash.lock.Unlock()return nil, err}ethash.rand = rand.New(rand.NewSource(seed.Int64()))}ethash.lock.Unlock()if threads == 0 {threads = runtime.NumCPU()}if threads < 0 {threads = 0 // Allows disabling local mining without extra logic around local/remote}var pend sync.WaitGroupfor i := 0; i < threads; i++ {pend.Add(1)go func(id int, nonce uint64) {defer pend.Done()ethash.mine(block, id, nonce, abort, found)}(i, uint64(ethash.rand.Int63()))}// Wait until sealing is terminated or a nonce is foundvar result *types.Blockselect {case <-stop:// Outside abort, stop all miner threadsclose(abort)case result = <-found:// One of the threads found a block, abort all othersclose(abort)case <-ethash.update:// Thread count was changed on user request, restartclose(abort)pend.Wait()return ethash.Seal(chain, block, stop)}// Wait for all miners to terminate and return the blockpend.Wait()return result, nil}```###### 该方法的foreach中并行挖新块,一旦停止或者找到新快,则废弃其他所有的,如果协程计算有变更,则重新调用方法###### 好了pow挖矿的核心方法已经出现,｀ethash.mine｀,如果挖取到新块,那么就写入到`found channel````// mine is the actual proof-of-work miner that searches for a nonce startin g from// seed that results in correct final block difficulty.func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort c han struct{}, found chan *types.Block) {// Extract some data from the headervar (header = block.Header()hash = header.HashNoNonce().Bytes()target = new(big.Int).Div(maxUint256, header.Difficulty)number = header.Number.Uint64()dataset = ethash.dataset(number))// Start generating random nonces until we abort or find a good onevar (attempts = int64(0)nonce = seed)logger := log.New("miner", id)logger.Trace("Started ethash search for new nonces", "seed", seed)for {select {case <-abort:// Mining terminated, update stats and abortlogger.Trace("Ethash nonce search aborted", "attempts", nonce-see d)ethash.hashrate.Mark(attempts)returndefault:// We don't have to update hash rate on every nonce, so update a fter after 2^X noncesattempts++if (attempts % (1 << 15)) == 0 {ethash.hashrate.Mark(attempts)attempts = 0}// Compute the PoW value of this noncedigest, result := hashimotoFull(dataset, hash, nonce)if new(big.Int).SetBytes(result).Cmp(target) <= 0 {// Correct nonce found, create a new header with itheader = types.CopyHeader(header)header.Nonce = types.EncodeNonce(nonce)header.MixDigest = common.BytesToHash(digest)// Seal and return a block (if still needed)select {case found <- block.WithSeal(header):logger.Trace("Ethash nonce found and reported", "attempts", n once-seed, "nonce", nonce)case <-abort:logger.Trace("Ethash nonce found but discarded", "attempts", n once-seed, "nonce", nonce)}return}nonce++}}}```###### `target`是目标新块的难度,`hashimotoFull`方法计算出一个hash值,如果产生的`hash`值小于等于`target`的值,则hash难度符合要求,将符合要求的`he ader`写入到`found channel`中,并返回,否则一直循环```// hashimotoFull aggregates data from the full dataset (using the full in-me mory// dataset) in order to produce our final value for a particular header hash and// nonce.func hashimotoFull(dataset []uint32, hash []byte, nonce uint64) ([]byte, []byt e) {lookup := func(index uint32) []uint32 {offset := index * hashWordsreturn dataset[offset : offset+hashWords]}return hashimoto(hash, nonce, uint64(len(dataset))*4, lookup)}``````// hashimoto aggregates data from the full dataset in order to produce our final// value for a particular header hash and nonce.func hashimoto(hash []byte, nonce uint64, size uint64, lookup func(index ui nt32) []uint32) ([]byte, []byte) {// Calculate the number of theoretical rows (we use one buffer nonethel ess)rows := uint32(size / mixBytes)// Combine header+nonce into a 64 byte seedseed := make([]byte, 40)copy(seed, hash)binary.LittleEndian.PutUint64(seed[32:], nonce)seed = crypto.Keccak512(seed)seedHead := binary.LittleEndian.Uint32(seed)// Start the mix with replicated seedmix := make([]uint32, mixBytes/4)for i := 0; i < len(mix); i++ {mix[i] = binary.LittleEndian.Uint32(seed[i%16*4:])}// Mix in random dataset nodestemp := make([]uint32, len(mix))for i := 0; i < loopAccesses; i++ {parent := fnv(uint32(i)^seedHead, mix[i%len(mix)]) % rowsfor j := uint32(0); j < mixBytes/hashBytes; j++ {copy(temp[j*hashWords:], lookup(2*parent+j))}fnvHash(mix, temp)}// Compress mixfor i := 0; i < len(mix); i += 4 {mix[i/4] = fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3])}mix = mix[:len(mix)/4]digest := make([]byte, common.HashLength)for i, val := range mix {binary.LittleEndian.PutUint32(digest[i*4:], val)}return digest, crypto.Keccak256(append(seed, digest...))}```###### 可以看到,该方法是不断的进行sha256的hash运算,然后返回进行has h值难度的对比,如果hash的十六进制大小小于等于预定的难度,那么这个hash 就是符合产块要求的产生一个随机seed,赋给nonce随机数，然后进行sha256的hash运算,如果算出的hash难度不符合目标难度,则nonce +1，继续运算worker.go/wait()func (self *worker) wait() {for {mustCommitNewWork := truefor result := range self.recv {atomic.AddInt32(&self.atWork, -1)if result == nil {continue}agent.go/mine()方法func (self *CpuAgent) mine(work *Work, stop <-chan struct{}) {if result, err := self.engine.Seal(self.chain, work.Block, stop); result != nil {("Successfully sealed new block", "number", result.Number(), " hash", result.Hash())self.returnCh <- &Result{work, result}} else {if err != nil {log.Warn("Block sealing failed", "err", err)}self.returnCh <- nil}}如果挖到一个新块，则将结果写到self的return管道中写块的方法WriteBlockAndStatewait方法接收self.recv管道的结果，如果有结果，说明本地挖到新块了，则将新块进行存储，并把该块放到待确认的block判定区miner.go/update方法，如果有新块出来，则停止挖矿进行下载同步新块，如果下载完成或失败的事件，则继续开始挖矿./geth/main.go/geth--> makeFullNode --> utils.RegisterEthService--> eth.New(ctx, cfg)--> miner.New(eth, eth.chainConfig, eth.EventMux(), eth.engine)这个是启动链后到挖矿，共识代码的整个调用栈，开始分析核心方法func New(eth Backend, config *params.ChainConfig, mux *event.TypeMux, engine consensus.Engine) *Miner {miner := &Miner{eth: eth,mux: mux,engine: engine,worker: newWorker(config, engine, common.Address{}, eth, mux),canStart: 1,}miner.Register(NewCpuAgent(eth.BlockChain(), engine))go miner.update()return miner}从miner.Update()的逻辑可以看出，对于任何一个Ethereum网络中的节点来说，挖掘一个新区块和从其他节点下载、同步一个新区块，根本是相互冲突的。

兄弟连区块链入门教程实战项目4Go语言打造区块链

兄弟连区块链入门教程实战项目4：Go语言打造区块链兄弟连区块链入门教程实战项目4：Go语言打造区块链“区块链+时代无疑会是下一个风口，然而现在的区块链行业专业型人才正在遭遇瓶颈”兄弟连教育区块链培训学院院长尹成表示，“希望能通过兄弟连教育区块链学院为社会为企业培养并输送更多优质的区块链高精尖型技术。

LearnGo打造全网最棒的Go语言学习项目第一阶段第1章：Go语言语法基础1.1 Go语言介绍1.2 Go语言开发环境搭建1.3 详解GOPATH1.4 Go语言基本数据类型1.5 常量、变量、表达式1.6 iota定义常量组1.7 标准输入与输出1.8 程序运算1：数学运算1.9 程序运算2：逻辑运算1.10 程序运算3：位运算1.11 流程控制1：选择结构1.12 流程控制2：循环结构1.13 流程控制3：延时执行defer1.14 流程控制4：直接跳转goto1.15 函数1：参数和返回值1.16 函数2：匿名函数1.17 函数3：闭包函数1.18 读取命令行参数1.19 复合类型1：数组1.20 复合类型2：切片1.21 复合类型3：映射1.22 复合类型4：结构体1.23 复合类型5：指针1.24 SDK标准库1：strings1.25 SDK标准库2：math1.26 SDK标准库3：os第2章：Go语言语法进阶2.1 面向对象1：封装2.2 面向对象2：继承2.3 面向对象3：多态2.4 面向对象4：接口与实现2.5 面向对象5：接口的继承2.6 面向对象5：接口的类型断言2.7 文件操作1：文件读写的一般操作2.8 文件操作2：实战案例2.9 JSON读写1：JSON序列化2.10 JSON读写2：JSON反序列化2.11 JSON读写3：读写JSON文件2.12 异常处理1：恐慌与处理2.13 异常处理2：返回错误2.14 异常处理3：自定义异常2.15 反射简介2.16 单元测试2.17 压力测试2.18 网络常识2.19 网络通信1：UDP2.20 网络通信2：TCP简单通信2.21 网络通信3：TCP交互通信2.22 网络通信4：TCP广播2.23 网络通信5：执行HTTP的GET/POST请求2.24 网络通信6：搭建HTTP服务器第3章：Linux与数据库3.1 Linux操作系统简介3.2 Linux日常命令3.3 Linux下搭建Go语言开发环境3.4 MySQL数据库1：简介与安装3.5 MySQL数据库2：基本增删改查3.6 MySQL数据库3：表结构与字段约束3.7 MySQL数据库4：表关系管理3.8 MySQL数据库5：多表联合查询3.9 MySQL数据库5：Go与MySQL的交互3.10 Redis数据库1：简介与安装3.11 Redis数据库2：常用数据操作3.12 Redis数据库3：常用管理操作3.13 Redis数据库4：Go与Redis的交互第4章：高并发与项目实战4.1 并发技术1：CSP并发理论4.2 并发技术2：多协程4.3 并发技术3：管道通信4.4 并发技术4：同步调度4.5 并发技术5：死锁问题4.6 正则表达式4.7 图形用户界面1：初识Walk4.8 图形用户界面2：常用控件4.9 实战项目1：基于开源数据的成语查询4.10 实战项目2：多人聊天室4.11 实战项目3：并发爬虫4.12 实战项目4：Go语言打造区块链。

Go语言中的ORM框架和数据库操作问题

Go语言中的ORM框架和数据库操作问题Go语言是一种开源的编程语言，具有高效、简洁和易于使用等特点。

在Go语言中，ORM框架和数据库操作是非常重要的话题。

本文将介绍Go语言中的ORM框架以及与数据库操作相关的问题。

一、什么是ORM框架ORM全称为Object-Relational Mapping，即对象关系映射。

ORM框架可以将数据库中的表和记录映射为编程语言中的对象和属性，使开发人员可以使用面向对象的思维来操作数据库，而不必直接使用SQL语句。

在Go语言中，目前比较流行的ORM框架有GORM、XORM等。

二、GORM框架的介绍GORM是Go语言中一款强大且易于使用的ORM框架。

它提供了一系列简单且功能丰富的函数，可以帮助开发人员快速、灵活地进行数据库操作。

GORM支持多种数据库，如MySQL、PostgreSQL、SQLite等，并提供了事务处理、查询构造器、模型关联等功能。

三、使用GORM进行数据库操作1. 安装GORM框架：在Go语言项目中使用GORM框架前，需要先安装对应的库文件。

可以通过go get命令来下载安装：go get -u gorm.io/gorm。

2. 连接数据库：在使用GORM框架前，需要先配置连接数据库的信息，包括数据库类型、地址、用户名、密码等。

可以通过gorm.Open 方法来创建数据库连接。

3. 定义模型：使用GORM框架时，需要定义与数据库表对应的模型结构体。

可以使用结构体的字段标签来指定对应的表名、字段名、主键等信息。

4. 创建表：在模型定义完成后，可以使用AutoMigrate方法来自动创建表结构。

GORM框架会根据模型结构体的字段信息创建相应的表和字段。

5. 数据操作：GORM框架提供了丰富的API，可以进行数据的增加、查询、修改和删除等操作。

通过调用相关的函数，可以很方便地实现对数据库的操作。

四、数据库操作问题及解决方法在使用ORM框架进行数据库操作时，可能会遇到一些常见问题。

兄弟连区块链培训教程之程序运算2：逻辑运算

兄弟连区块链培训教程之程序运算2：逻辑运算首先Go是谷歌2009发布的第二款编程语言。

今天兄弟连Go语言+区块链培训老师给大家介绍一下关于Go语言中程序运算2：逻辑运算，很多人喜欢Go语言，其实是因为Go 语言有其独特的语言属性在支撑着其在编程语言界的发展，下面我们一起来看一下吧。

逻辑运算概述∙逻辑运算的结果是true或false∙逻辑运算符包括相等,与或非：==,&&,||,!∙条件与：同时为真就为真∙条件或：只要有一个为真，结果就为真∙条件非：对结果取反func main() {//a1,b1为true// a0,b0为falsevar a1 = (5 > 3)var a0 = (5 < 3)var b1 = (5 == (2 + 3))var b0 = (5 != (2 + 3))//true truefmt.Println(a1, b1)//false falsefmt.Println(a0, b0)//条件与：同时为真就为真//truefmt.Println(a1 && b1)//falsefmt.Println(a1 && b0)//条件或：只要有一个为真，结果就为真//truefmt.Println(a1 || b1)//truefmt.Println(a1 || b0)//falsefmt.Println(a0 || b0)//条件非：对结果取反//false falsefmt.Println(!a1, !b1)//true truefmt.Println(!a0, !b0)}。

兄弟连区块链技术培训分享Go语言测试用例

兄弟连区块链技术培训分享Go语言测试用例Go语言经过十余年的发展，已成为最流行的新兴语言。

目前，Go语言已成为云计算领域的首选语言，且随着近几年区块链的流行，作为底层开发语言的Go再次火爆成为区块链领域第一编程语言，IBM的Fabic等重量级的区块链项目都是基于Go语言开发的。

殊不知，Go语言可开发的应用项目还有很多。

除云计算、区块链等开源项目外，还包含Devops、人工智能、游戏、存储引擎、Web、系统/命令行工具、中间件、测试/持续交付、文件系统等各方面的开源项目。

编写单元测试用例文件名必须以'_test.go'结尾必须import "testing"这个包测试用例会按照源代码中写的顺序依次执行测试函数'TestXxx(t *testing.T)'中的参数是‘testing.T’,我们可以用该类型来记录错误或者是测试状态测试格式：‘func TestXxx(t *testing.T)’,'Xxx'部分可以为任意的字母数字组合，但是首字母不能是小写字母[a-z]函数中通过调用'testing.T'的'Error'、'Errorf'、'FailNow'、'Fatal'、‘FatalIf’方法，说明测试用例不通过，调用''Log'方法用来记录测试的信息编写压力测试压力测试用例必须遵循如下格式，其中XXX可以是任意字母数字的组合，但是首字母不能是小写字母func BenchmarkXXX(b *testing.a) {...}go test 不会默认执行压力测试的函数，如果要执行压力测试需要带上参数。

-test.bench,语法: -test.bench="test_name_regex" ,例如go test -test.bench=".*"表示测试全部的压力测试函数在压力测试用例中，需要才循环体内使用testing.B.N,以使测试用例正常运行文件名也必须以_test.go结尾单元测试用例源码package gotestimport()func Add(a, b float64) float64 {return a + b}测试用例1 / 3package gotestimport ("testing")func Test_Add_1(t *testing.T) {if i := Add(6,2); i != 8 {t.Error("fail")} else {t.Log("pass")}}func Test_Add_2(t *testing.T) {if i := Add(6,2); i == 8 {t.Log("pass")} else {t.Error("fail")}}运行测试用例go test -v测试用例执行结果=== RUN Test_Add_1--- PASS: Test_Add_1 (0.00s)gotest_test.go:11: pass=== RUN Test_Add_2--- PASS: Test_Add_2 (0.00s)gotest_test.go:17: passPASSok /shadowsocks/shadowsocks-go/sample-config/gotest 0.001s 压力测试用例源码package gotestimport("testing"2 / 3)func Benchmark_Add(b *testing.B) {for i := 0; i < b.N ; i++ {Add(3,4)}}func Benchmark_TimeConsumingFunction(b *testing.B) {b.StopTimer() //调用该函数停止压力测试的时间计数//做一些初始化工作，这些时间不影响我们测试函数本身的性能b.StartTimer()for i := 0; i < b.N; i++ {Add(5,6)}}运行结果Benchmark_Add-4 2000000000 0.38 ns/op Benchmark_TimeConsumingFunction-4 2000000000 0.38 ns/op PASSok /shadowsocks/shadowsocks-go/sample-config/gotest 1.594s第一条显示Benchmark_add-4执行了20亿次，每次执行时间为0.38纳秒第二条也一样3 / 3。

兄弟连区块链培训分享Go语言-写并发注意事项

兄弟连区块链培训分享Go语言-写并发注意事项“区块链是一门集合密码学、共识算法、智能合约、超级账本等多门技术的复杂性综合学科。

”尹正表示，区块链培训机构的师资质量及其对区块链行业的认知水平参差不齐，普通消费者也无从考究。

Go语言主要用作服务器端开发，其定位是用来开发“大型软件”的，适合于很多程序员一起开发大型软件，并且开发周期长，支持云计算的网络服务。

Go语言能够让程序员快速开发，并且在软件不断的增长过程中，它能让程序员更容易地进行维护和修改。

它融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性。

写go语言并发需要注意的几点：1. golang 1.2版本goroutine的runtime.GOMAXPROCS 如果没有被定义，默认是1，从1.5之后改为默认是runtime.CpuNum()，go底层其实是并发GOMAXPROCS 个线程，然后进行并发。

但是并发也是每个goroutine分先后进行运行，并不是真正的并发轮询，所以必须让goroutine 的加入轮询调度runtime.Gosched()，保证所有goroutine齐头并进，以下面程序为例，如果不加入go的轮询调度，由于say函数goroutine是死循环，所以永远不会进行上下文切换，也就导致了永远输出不了world,主线程会一直占据着cpu时间片。

package mainimport ("fmt""runtime")func say(s string) {for i := 0; i < 5; i++ {runtime.Gosched() //让执行此函数的goroutine进行go的轮询调度fmt.Println(s)}}func main() {go say("world")say("hello")}1 / 1。

兄弟连区块链技术培训分享Go语言中的var

兄弟连区块链技术培训分享Go语言中的var2018年第一季度，区块链相关人才的招聘需求已达到2017年同期的9.7倍，发布区块链相关岗位的公司数量同比增长4.6倍。

兄弟连教育Go全栈与区块链课程是由清华、微软和谷歌名师历时半年时间研发出的独一无二的体系化课程。

go语言中定义变量使用关键字var，如：var x int=4也可以写成x:=4;在函数中，:= 简洁赋值语句在明确类型的地方，可以用于替代var 定义。

（:= 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始。

）package mainimport ("fmt")func main() {var x int = 4fmt.Println(x)//输出4fmt.Println(&x)//输出指针//fmt.Println(*x) //错误y := 4fmt.Println(y)//输出4fmt.Println(&y)//输出指针//fmt.Println(*y) //错误var v *int = new(int)//返回值为指针fmt.Println(*v)//输出为0，它只是将内存清零，而不是初始化内存*v = 4//赋值fmt.Println(v)//输出指针fmt.Println(*v)//输出4z := new(int)//代替var v *int = new(int)*z = 3fmt.Println(z)//输出指针fmt.Println(*z)//输出3}总结go语言的变量定义返回值中隐含了指针，可以进行取指针操作，不嫩进行取值操作。

new和make的区别（转）内存分配new 是一个分配内存的内建函数，但不同于其他语言中同名的new所作的工作，它只是将内存清零，而不是初始化内存。

new(T)为一个类型为T的新项目分配了值为零的存储空间并返回其地址，也就是一个类型为*T的值。

用Go的术语来说，就是它返回了一个指向新分配的类型为T的零值的指针。

兄弟连Go语言培训分享类和接口的使用

Go语言是谷歌2009发布的第二款开源编程语言。

Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C 或C++代码的速度，而且更加安全、支持并行进程。

不仅可以开发web,可以开发底层，目前知乎就是用golang开发。

区块链首选语言就是go,以-太=坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。

由于存在并行编程模式，因此这一语言也被设计用来解决多处理器的任务。

Google对Go寄予厚望。

其设计是让软件充分发挥多核心处理器同步多工的优点，并可解决面向对象程序设计的麻烦。

它具有现代的程序语言特色，如垃圾回收，帮助程序设计师处理琐碎但重要的内存管理问题。

Go的速度也非常快，几乎和C或C++程序一样快，且能够快速制作程序。

类使用：实现一个people中有一个sayhi的方法调用功能，代码如下：type People struct {//..}func (p *People) SayHi() {fmt.Printlnfunc (this *LoginController) Get() {p := new(People)p.SayHi()this.TplName = "login.html"}接口使用：实现上面功能，代码如下：type People struct {//..}func (p *People) SayHi() {fmt.Printlntype IPeople interface {SayHi()}func (this *LoginController) Get() {var p IPeople = new(People)p.SayHi()this.TplName = "login.html"}1 / 1。