区块链数据结构

+-------------------------------------------------------+
|                                                       |
|           +----------------------+                    |
|           | Version              |                    |
|           | Previous Block Hash  |                    |
|           | Merkle Root          |                    |
|           | Timestamp            |                    |
|           | Difficulty Target    |                    |
|           | Nonce                |                    |
|           +----------------------+                    |
|                                                       |
+-------------------------------------------------------+

+-------------------------------------------------------+
|                                                       |
|           +----------------------+                    |
|           | Transactions         |                    |
|           +----------------------+                    |
|           | Transaction 1        |                    |
|           | Transaction 2        |                    |
|           | Transaction 3        |                    |
|           | ...                  |                    |
|           +----------------------+                    |
|           | Transaction Counter  |                    |
|           +----------------------+                    |
|                                                       |
+-------------------------------------------------------+

+-------------------------------------------------------+
|                                                       |
|           +----------------------+                    |
|           | Block Header         |                    |
|           +----------------------+                    |
|           | Version              |                    |
|           | Previous Block Hash  |                    |
|           | Merkle Root          |                    |
|           | Timestamp            |                    |
|           | Difficulty Target    |                    |
|           | Nonce                |                    |
|           +----------------------+                    |
|                                                       |
|           +----------------------+                    |
|           | Transactions         |                    |
|           +----------------------+                    |
|           | Transaction 1        |                    |
|           | Transaction 2        |                    |
|           | Transaction 3        |                    |
|           | ...                  |                    |
|           +----------------------+                    |
|                                                       |
|                                                       |
|           +----------------------+                    |
|           | Block Hash           |                    |
|           +----------------------+                    |
|                                                       |
+-------------------------------------------------------+

package main

import (
  "crypto/sha256"
  "encoding/hex"
  "time"
)

// 区块结构体
type Block struct {
  // 区块头
  Version       int64  // 版本号
  PreviousHash  string // 前一区块哈希值
  MerkleRoot    string // Merkle 根哈希值
  Timestamp     int64  // 时间戳
  Difficulty    int64  // 难度目标
  Nonce         int64  // 随机数
  // 区块体
  Transactions  []*Transaction // 交易信息
  TransactionNum int64          // 交易数量
}

// 交易结构体
type Transaction struct {
  From   string // 发送方地址
  To     string // 接收方地址
  Amount int64  // 交易金额
  Time   int64  // 交易时间
}

// 计算区块哈希值
func (b *Block) calculateHash() string {
  blockData := string(b.Version) + b.PreviousHash + b.MerkleRoot + string(b.Timestamp) + string(b.Difficulty) + string(b.Nonce)
  hash := sha256.Sum256([]byte(blockData))
  return hex.EncodeToString(hash[:])
}

// 创建新区块
func newBlock(previousBlock *Block, transactions []*Transaction) *Block {
  block := &Block{
    Version:        1,
    PreviousHash:   previousBlock.calculateHash(),
    MerkleRoot:     "merkle_root",
    Timestamp:      time.Now().UnixNano(),
    Difficulty:     1,
    Nonce:          0,
    Transactions:   transactions,
    TransactionNum: int64(len(transactions)),
  }
  return block
}

// 测试代码
func main() {
  // 创建创世区块
  genesisBlock := &Block{
    Version:        1,
    PreviousHash:   "",
    MerkleRoot:     "merkle_root",
    Timestamp:      time.Now().UnixNano(),
    Difficulty:     1,
    Nonce:          0,
    Transactions:   []*Transaction{},
    TransactionNum: 0,
  }
  // 创建新区块
  transactions := []*Transaction{
    {From: "alice", To: "bob", Amount: 10, Time: time.Now().UnixNano()},
    {From: "bob", To: "charlie", Amount: 5, Time: time.Now().UnixNano()},
  }
  newBlock := newBlock(genesisBlock, transactions)
  // 输出新区块信息
  println("Block Version:", newBlock.Version)
  println("Previous Block Hash:", newBlock.PreviousHash)
  println("Merkle Root Hash:", newBlock.MerkleRoot)
  println("Timestamp:", newBlock.Timestamp)
  println("Difficulty Target:", newBlock.Difficulty)
  println("Nonce:", newBlock.Nonce)
  println("Transactions:", newBlock.Transactions)
  println("Transaction Number:", newBlock.TransactionNum)
  println("Block Hash:", newBlock.calculateHash())
}

package main

import (
  "crypto/sha256"
  "encoding/hex"
  "fmt"
)

func main() {
  // 定义消息
  message := "Hello, world!"
  // 计算SHA-256哈希值
  hash := sha256.Sum256([]byte(message))
  // 输出哈希值
  fmt.Println("Message:", message)
  fmt.Println("Hash:", hex.EncodeToString(hash[:]))
}

package main

import (
  "crypto/ecdsa"
  "crypto/elliptic"
  "crypto/rand"
  "crypto/sha256"
  "fmt"
  "golang.org/x/crypto/ripemd160"
  "math/big"
)

func main() {
  // 选择椭圆曲线secp256k1和基点G
  curve := elliptic.P256k1()
  x, _ := new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16)
  y, _ := new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16)
  G := ecdsa.PublicKey{Curve: curve, X: x, Y: y}

  // 生成私钥
  privateKey, err := ecdsa.GenerateKey(curve, rand.Reader)
  if err != nil {
    fmt.Println("Generate Private Key Error:", err)
    return
  }

  // 生成公钥
  publicKey := privateKey.PublicKey

  // 对公钥进行哈希运算
  publicKeyBytes := elliptic.Marshal(curve, publicKey.X, publicKey.Y)
  hash := sha256.Sum256(publicKeyBytes)
  ripemd160Hasher := ripemd160.New()
  _, err = ripemd160Hasher.Write(hash[:])
  if err != nil {
    fmt.Println("Hash Public Key Error:", err)
    return
  }
  hash160 := ripemd160Hasher.Sum(nil)

  // 添加版本号和校验码
  version := []byte{0}
  payload := append(version, hash160...)
  checksum := sha256.Sum256(sha256.Sum256(payload))
  payload = append(payload, checksum[:4]...)

  // 将版本号、哈希值和校验码组合成一个Base58编码的字符串，得到钱包地址
  address := base58Encode(payload)
  fmt.Println("Address:", address)
}

func base58Encode(payload []byte) string {
  alphabet := "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
  var x big.Int
  x.SetBytes(payload)

  var result []byte
  for x.Cmp(big.NewInt(0)) > 0 {
    mod := new(big.Int)
    x.DivMod(&x, big.NewInt(58), mod)
    result = append(result, alphabet[mod.Int64()])
  }

  for _, b := range payload {
    if b != 0 {
      break
    }
    result = append(result, alphabet[0])
  }

  for i, j := 0, len(result)-1; i < j; i, j = i+1, j-1 {
    result[i], result[j] = result[j], result[i]
  }

  return string(result)
}

package main

import (
  "crypto/ecdsa"
  "crypto/elliptic"
  "crypto/rand"
  "crypto/sha256"
  "golang.org/x/crypto/ripemd160"
  "math/big"
)

func main() {
  // 选择椭圆曲线secp256k1和基点G
  curve := elliptic.P256k1()
  x, _ := new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16)
  y, _ := new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16)
  G := ecdsa.PublicKey{Curve: curve, X: x, Y: y}

  // 生成私钥
  privateKey, err := ecdsa.GenerateKey(curve, rand.Reader)
  if err != nil {
    panic(err)
  }

  // 生成公钥
  publicKey := privateKey.PublicKey

  // 生成交易哈希值
  txHash := sha256.Sum256([]byte("Transaction Data"))
  ripemd160Hasher := ripemd160.New()
  _, err = ripemd160Hasher.Write(txHash[:])
  if err != nil {
    panic(err)
  }
  hash160 := ripemd160Hasher.Sum(nil)

  // 签名
  r, s, err := ecdsa.Sign(rand.Reader, privateKey, hash160)
  if err != nil {
    panic(err)
  }
  signature := append(r.Bytes(), s.Bytes()...)

  // 验证签名
  Px, Py := publicKey.Curve.ScalarBaseMult(privateKey.D.Bytes())
  P := ecdsa.PublicKey{Curve: curve, X: Px, Y: Py}
  Qx, Qy := elliptic.Unmarshal(curve, publicKey.X)
  Q := ecdsa.PublicKey{Curve: curve, X: Qx, Y: Qy}
  if !ecdsa.Verify(&P, hash160, new(big.Int).SetBytes(signature[:32]), new(big.Int).SetBytes(signature[32:])) {
    panic("Invalid Signature")
  }
  if !ecdsa.Verify(&Q, hash160, new(big.Int).SetBytes(signature[:32]), new(big.Int).SetBytes(signature[32:])) {
    panic("Invalid Signature")
  }
}

package main

import (
  "crypto/ecdsa"
  "crypto/elliptic"
  "crypto/rand"
  "fmt"
  "math/big"
)

func main() {
  // 选择椭圆曲线secp256k1和基点G
  curve := elliptic.P256k1()
  x, _ := new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16)
  y, _ := new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16)
  G := ecdsa.PublicKey{Curve: curve, X: x, Y: y}

  // 生成私钥d1和公钥Q1
  privateKey1, err := ecdsa.GenerateKey(curve, rand.Reader)
  if err != nil {
    panic(err)
  }
  publicKey1 := privateKey1.PublicKey

  // 生成私钥d2和公钥Q2
  privateKey2, err := ecdsa.GenerateKey(curve, rand.Reader)
  if err != nil {
    panic(err)
  }
  publicKey2 := privateKey2.PublicKey

  // 计算共享密钥
  x, _ = curve.ScalarMult(publicKey2.X, publicKey2.Y, privateKey1.D.Bytes())
  y, _ = curve.ScalarMult(publicKey2.X, publicKey2.Y, privateKey1.D.Bytes())
  K := elliptic.Marshal(curve, x, y)

  fmt.Println(K)
}

package main

import (
  "crypto/sha256"
  "encoding/hex"
  "fmt"
)

// 默克尔树节点结构体
type MerkleNode struct {
  Left  *MerkleNode
  Right *MerkleNode
  Data  []byte
}

// 计算节点哈希值
func (node *MerkleNode) calculateHash() []byte {
  if node == nil {
    return nil
  }
  hash := sha256.Sum256(node.Data)
  return hash[:]
}

// 创建新节点
func newMerkleNode(left, right *MerkleNode, data []byte) *MerkleNode {
  node := &MerkleNode{
    Left:  left,
    Right: right,
    Data:  data,
  }
  if left != nil && right != nil {
    hashData := append(left.calculateHash(), right.calculateHash()...)
    node.Data = sha256.Sum256(hashData)[:]
  }
  return node
}

// 创建默克尔树
func newMerkleTree(data [][]byte) *MerkleNode {
  var nodes []*MerkleNode

  for _, datum := range data {
    node := newMerkleNode(nil, nil, datum)
    nodes = append(nodes, node)
  }

  for len(nodes) > 1 {
    var newLevel []*MerkleNode

    for i := 0; i < len(nodes); i += 2 {
      left := nodes[i]
      var right *MerkleNode
      if i+1 < len(nodes) {
        right = nodes[i+1]
      }
      newNode := newMerkleNode(left, right, nil)
      newLevel = append(newLevel, newNode)
    }

    nodes = newLevel
  }

  return nodes[0]
}

// 测试代码
func main() {
  // 创建交易数据
  data := [][]byte{
    []byte("Transaction 1"),
    []byte("Transaction 2"),
    []byte("Transaction 3"),
    []byte("Transaction 4"),
  }

  // 创建默克尔树
  root := newMerkleTree(data)

  // 输出根哈希值
  fmt.Println("Root Hash:", hex.EncodeToString(root.calculateHash()))
}