Todas las implementaciones de este código se han sincronizado de código abierto en github, dirección del proyecto:
enlace
Introducción al algoritmo PoW
Prueba de trabajo (POW para abreviar), la comprensión simple es una prueba para confirmar que ha realizado una cierta cantidad de trabajo. Todo el proceso de seguimiento del trabajo suele ser extremadamente ineficiente, y es una forma muy eficiente de demostrar que se ha completado la carga de trabajo correspondiente mediante la certificación de los resultados del trabajo. Por ejemplo, certificados de graduación, licencias de conducir, etc. en la vida real también son pruebas obtenidas por medio de resultados de inspección (aprobación de exámenes relevantes).
El sistema de prueba de trabajo (o protocolo, función) es una contramedida económica contra los ataques de denegación de servicio y otros abusos del servicio. Requiere que el iniciador realice una cierta cantidad de cálculo, lo que significa que la computadora necesita consumir una cierta cantidad de tiempo.
Ideas de algoritmos PoW
El algoritmo de consenso se realiza mediante el hash continuo de los datos del nodo y comparando el hash objetivo con el valor hash actual.
Ideas de código e implementación
Ideas de pseudocódigo:
1. Cree una clase ProofOfWork con dos atributos {target hash, target block}
2. Calcule el hash del bloque objetivo a través de la clase ProofOfWork y compárelo con el hash objetivo.
3. Si se determina que el valor hash del bloque objetivo es menor que el valor hash objetivo, la prueba de carga de trabajo se completa, transmite y carga en la cadena.
La estructura de ProofOfWork:
// 工作量证明的结构
type ProofOfWork struct {
//需要共识验证的区块
Block *Block
//目标难度的哈希,大数存储
target *big.Int
}
Compara los valores hash:
func (pow *ProofOfWork) run() ([]byte, int64) {
//碰撞次数
var nonce = int64(0)
//用于比较的大数hash
var hashInt big.Int
//目标hash值
var hash [32]byte
//无限循环，生成符合条件的哈希
for {
//生成准备数据
dataByte := pow.prepareData(int64(nonce))
hash = sha256.Sum256(dataByte)
//将byte数据转换为大数
hashInt.SetBytes(hash[:])
if pow.target.Cmp(&hashInt) == 1 {
//找到了符合条件的hash
break
}
nonce++
}
fmt.Printf("打印碰撞次数%v\n", nonce)
return hash[:], nonce
}
Unir datos de bloque para facilitar el cálculo del valor hash:
// 生成准备数据，对ProofOfWork数据拼接形成哈希值并返回
func (pow *ProofOfWork) prepareData(nonce int64) []byte {
var data []byte
timeStampBytes := IntToHex(pow.Block.TimeStamp)
heightBytes := IntToHex(pow.Block.Height)
//将多个[]byte数组转换为一个[]byte数组
data = bytes.Join([][]byte{
timeStampBytes,
heightBytes,
pow.Block.PrevBlockHash,
pow.Block.Data,
IntToHex(nonce),
IntToHex(targetBit),
}, []byte{
})
return data
}
Resultados experimentales
Se puede ver que se generan un total de tres bloques, y el número de colisiones en cada bloque es el siguiente. Finalmente, se emite toda la cadena de bloques y se puede ver que los valores hash de los bloques presentan una estructura de lista enlazada.
