go语言实现简易比特币系统钱包的原理解析

时间：2022-11-15 07:51:25

钱包基础概念

  • 广义上，钱包是一个应用程序，为用户提供交互界面。钱包控制用户访问权限、管理比特比地址及秘钥、跟踪余额、创建交易和签名交易
  • 狭义上，即从程序员角度来看，“钱包”是指用于存储和管理用户秘钥的数据结构
  • 钱包是私钥的容器，一般是通过结构化文件或简单数据库来实现的
  • 钱包中并不包含比特币。比特币是被记录在比特币网络的区块链中，用户通过钱包中的密钥签名交易，从而控制网络中的比特币，在某种意义上，比特币钱包就是密钥链

钱包结构体

?
1
2
3
4
5
6
type Wallet struct {
    //私钥
    Private *ecdsa.PrivateKey
    //约定，这里的PubKey不存储原始的公钥，而是存储X和Y拼接的字符串，在校验端重新拆分（参考r,s传递）
    PubKey []byte
}

创建钱包

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func NewWallet() *Wallet {
    //创建曲线
    curve := elliptic.P256()
    //生成私钥
    privateKey, err := ecdsa.GenerateKey(curve, rand.Reader)
    if err != nil {
        log.Panic(err)
    }
 
    //生成公钥
    pubKeyOrig := privateKey.PublicKey
 
    //拼接X, Y
    pubKey := append(pubKeyOrig.X.Bytes(), pubKeyOrig.Y.Bytes()...)
 
    return &Wallet{Private: privateKey, PubKey: pubKey}
}

钱包集结构体

?
1
2
3
4
5
//定一个 Wallets结构，它保存所有的wallet以及它的地址
type Wallets struct {
    //map[地址]钱包
    WalletsMap map[string]*Wallet
}

创建钱包集

?
1
2
3
4
5
6
7
func NewWallets() *Wallets {
  var ws Wallets
  ws.WalletsMap = make(map[string]*Wallet)
  //加载本地钱包，把新建的钱包保存到本地
  ws.loadFile()
  return &ws
}

创建钱包到钱包集

?
1
2
3
4
5
6
7
8
9
10
11
12
13
func (ws *Wallets) CreateWallet() string {
    //创建一个钱包
    wallet := NewWallet()
    address := wallet.NewAddress()
 
    //添加到钱包集
    ws.WalletsMap[address] = wallet
 
    //保存包本地
    ws.saveToFile()
    //返回创建钱包的地址
    return address
}

保存钱包到本地

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func (ws *Wallets) saveToFile() {
 
    var buffer bytes.Buffer
 
    gob.Register(elliptic.P256())
 
    encoder := gob.NewEncoder(&buffer)
    err := encoder.Encode(ws)
    //一定要注意校验！！！
    if err != nil {
        log.Panic(err)
    }
 
    ioutil.WriteFile(walletFile, buffer.Bytes(), 0600)
}

读取钱包集里的钱包

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
func (ws *Wallets) loadFile() {
    //在读取之前，要先确认文件是否在，如果不存在，直接退出
    _, err := os.Stat(walletFile)
    if os.IsNotExist(err) {
        return
    }
 
    //读取内容
    content, err := ioutil.ReadFile(walletFile)
    if err != nil {
        log.Panic(err)
    }
 
    //解码
    gob.Register(elliptic.P256())
 
    decoder := gob.NewDecoder(bytes.NewReader(content))
 
    var wsLocal Wallets
 
    err = decoder.Decode(&wsLocal)
    if err != nil {
        log.Panic(err)
    }
 
    ws.WalletsMap = wsLocal.WalletsMap
}

列出所有钱包的地址

?
1
2
3
4
5
6
7
8
9
func (ws *Wallets) ListAllAddresses() []string {
    var addresses []string
    //遍历钱包，将所有的key取出来返回
    for address := range ws.WalletsMap {
        addresses = append(addresses, address)
    }
 
    return addresses
}

生成钱包地址

  • 随机选取32byte的数字作为私钥
  • 使用椭圆曲线加密算法（ECDSA-secp256k1）计算私钥对应的非压缩公钥
  • 计算公钥的SHA-256哈希值
  • 取上一步结果，计算RIPEMD-160哈希值
  • 取上一步结果，前面加上版本号（比特币主网版本号“0x00”）
  • 取上一步结果，计算SHA-256哈希值
  • 取上一步结果，计算SHA-256哈希值
  • 取上一步结果的前4个字节（8位十六进制）
  • 把这4个字节加在第五步的结果后面，作为校验（这就是比特币地址的十六进制形态）
  • 用base58表示法变换一下地址（这就是常见的比特币地址形态）
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//生成地址
func (w *Wallet) NewAddress() string {
    //钱包公钥
    pubKey := w.PubKey
 
    //计算公钥哈希和ripe160
    rip160HashValue := HashPubKey(pubKey)
    //主网版本号为0x00
    version := byte(00)
    //拼接version
    payload := append([]byte{version}, rip160HashValue...)
 
    //校验码checksum
    checkCode := CheckSum(payload)
 
    //拼接版本、哈希值、校验码、25字节数据
    payload = append(payload, checkCode...)
 
    //base58编码
    address := base58.Encode(payload)
 
    return address
}

结束

源码：https://gitee.com/xiaoshengdada/go_bitcoin/tree/master/v5

到此这篇关于go语言实现简易比特币系统钱包的原理解析的文章就介绍到这了,更多相关go实现比特币钱包内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_31639829/article/details/115426339

标签：

相关文章