区块链的基本认识——BTC

一、什么是区块链

一种。 定义：

本质上，区块链是通过多台计算机保存和同步用户的一些特定信息（如交易信息）的过程。 每个区块都记录了对应的交易信息，这些交易信息串联起来形成了所谓的区块链，它是一个类似数据库的文件db，存储在许多计算机节点中。

从技术上讲，区块链是分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的一种新型应用模式。 区块链技术基本上设计了当今世界上所有与计算机相关的问题。 区块链技术推动计算机计算速度的发展，不断更新迭代优化计算机的软硬件性能。

在用途上，区块链是一套以几乎不可能伪造或篡改的方式构建的数据存储数学架构，可用于存储各种有价值的数据。

b. 特征：

C。 区块链图：

2. BTC在区块链中的基本构成

如下图所示，这些是 BTC 的四个基本构建块

a.BTC区块链区块链：

区块链用于将所有生成的区块串联起来。 区块链的高度表示当前拥有的区块总数。 区块链每十分钟广播一次，将完成的区块交易信息内容添加到区块链中，同时奖励完成区块ID查找的矿机。 每四年，产生区块的矿机奖励的BTC就会减半。 所以，比特币是一种收敛货币，在没有货币通货膨胀的情况下（BTC的产生见下图），比特币之所以能维持到2140年，是因为比特币系统会根据挖矿难度进行调整到电脑算力的变化，从而控制BTC的发行速度！

代码如下：

 1 import matplotlib.pyplot as plt 
 2 from PIL import Image
 3 import time
 4 import sys
 5 import os
 6 
 7 # 初始奖励50BTC
 8 start_block_reward = 50
 9 # 以10分钟为一个区块间隔，210000块=4Year*365Day*24Hour*6，需要4年
10 reward_interval = 210000
11 
12 Year = []
13 Satoshis = []
14 
15 def max_money():
16         # 50 BTC = 50 0000 0000 Satoshis
17         current_reward = 50 * 10**8
18         total = 0
19         year = 2008
20         while current_reward > 0:
21                 total += reward_interval * current_reward
22                 Satoshis.append(total)
23                 current_reward /= 2
24                 Year.append(year)
25                 year += 4
26         return total
27 print("Total BTC to ever be created:", max_money(), "Satoshis")
28 print("1 BTC = 100000000 Satoshis!")
29 
30 plt.xlim((2008,2140))
31 plt.plot(Year,Satoshis)

32 plt.show()

查看代码

代码运行结果：

截至2140年共计2100万枚BTC

注意：区块链分叉是由于世界各地的网络状况不同。 可能同时产生两个块，一个在欧洲A，一个在南美B，那么离节点A最近的先收到A的。 广播，距离nodeB最近的同一个节点最先接收到来自B的广播，所以在两个节点的确认次数增加后，就会出现区块链的分叉，分叉会暂时保存到下一个区块的时候区块出来，甚至下一个区块出现，区块链最长的那一边会成为最后的区块链，这样区块链就会收敛到同一条区块链，保证了区块链的完整性。 独特性。

b. BTC区块区块：

当前大部分交易的内容都存储在区块Block中，那么谁产生了区块，也就是矿工（miners），矿工收集网络节点上的所有交易信息，根据每笔交易的交易费用提供完成优先级排序。 交易费用越高，越容易快速处理。 矿工在确认这些高优先级的交易信息后，会打包交易信息，存储打包后的数据，并开始生成区块对应的区块ID（一个很难计算的HASH值），如果矿工先找到HASH-满足要求的价值，则获得本次比特币奖励和收取的交易手续费。 下面简单看下如何计算出符合要求的HASH值：

代码如下：

 1 import numpy as np 
 2 # Hash哈希运算库-SHA128 SHA256 MD5
 3 import hashlib
 4 import time
 5 import sys
 6 import os
 7 # 工作量证明算法
 8 max_nonce = 2**32 # 4 billion
 9 
10 def proof_of_work(header,difficulty_bits):
11         # calc the difficulty target
12         target = 2**(256-difficulty_bits)
13         for nonce in range(max_nonce):
14                 temp = str(header)+str(nonce)
15                 hash_result = hashlib.sha256(temp.encode('utf-8')).hexdigest()
16                 # check if this is a valid result,below the target
17                 if int(hash_result,16) < target:
18                         print("Success with nonce %d" % nonce)
19                         print("Hash is %s" % hash_result)
20                         return hash_result,nonce
21         print("Failed after %d (max_nonce) tries" % max_nonce)
22 
23 Start_time = time.time()
24 proof_of_work('Hash_val',22)
25 End_time = time.time()
26 print('The time cost:', End_time-Start_time, 's')

代码运行结果：

我们可以看到，当难度为22时，计算出一个符合要求的Hash值所需时间约为6.7s。 随着难度的增加，这个时间会成倍增长！

C。 BTC交易兑换：

在BTC交易过程中比特币交易信息有哪些，我们可以用比特币换取我们想要的物品，也可以将比特币转给别人。 无论哪种方式，我们都需要将指定的BTC转入对应的钱包地址。

当BTC没有交易时，BTC处于UTXO状态。 这种状态一直被封锁，直到BTC的拥有者通过自己的私钥和数字签名释放BTC，完成转账功能。 转账完成后，BTC 可能仍然存在。 找零，找零的BTC会处于UTXO状态，接收方的比特币地址，即钱包地址处于URTX状态，等待相应的转账功能！

相关知识点：数字签名、

d. BTC钱包钱包：

BTC钱包主要涉及以下三个部分：

1.私钥Private-Key：

定义：一个随机生成的数字，控制比特币地址中的资金对应私钥的所有权和控制权。 私钥用于支付比特币必要的签名，证明资金的所有权。 私钥必须保密。

私钥创建：生成密钥的第一步是找到足够安全的熵源，即随机源。 我们可以使用python中的随机函数来生成我们的密钥，也可以使用椭圆曲线密码ECC函数来生成我们的密钥。 函数如下：

1 numpy:key = np.random.random()
2 Key = EEC_Encrypte()     

2.公钥Public-Key：

定义：通过椭圆曲线乘法得到我们需要的公钥。 这个 ge 过程是不可逆的。 私钥作为ECC函数的输入，得到公钥的输出结果。

椭圆曲线方程：

BTC采用的EEC方程为secp256k1标准所定义 的一条特殊的曲线以及一系列的数学常数，该 标准由NIST设立： 

Function：y^2 mod p = (x^3+7) mod p 
素数p：2^256-2^32-2^9-2^8-2^7-2^6-2^4-1 
G点：称为生成点的常数点
加法运算：P1+P2=P3(P3为曲线上P1和P2两点 连线与椭圆曲线的交点) 
乘法运算：k*P=P+P+...+P(k个P相加)

绘制椭圆曲线的离散图像：

 1 import matplotlib.pyplot as plt 
 2 from PIL import Image
 3 import numpy as np 
 4 # Hash哈希运算库-SHA128 SHA256 MD5
 5 import hashlib
 6 # OepnSSL加密库-EEC椭圆曲线加密函数计算公钥
 7 import OpenSSL
 8 import random
 9 import time
10 import sys
11 import os
12 
13 # 学习如何使用EEC椭圆曲线加密问题，ECC函数的实现方式等等
14 # The ecc function is: (x^3+7) mod P = y^2 mod P
15 P = 17
16 x= np.linspace(0,P,P,dtype='int')
17 y = list()
18 for i in x:
19     temp = (i**3 + 7) % P
20     append_flag = 0
21     for j in range(0,P):
22         if j**2 % P == temp:
23             y.append(j)
24             append_flag = 1
25             break
26     if append_flag == 0:
27         y.append(-1)
28 Y = np.array(y)
29 X = x
30 plt.xlim( (0, P) )
31 plt.ylim( (0, P) )
32 plt.scatter(X, Y)

33 # Y^2 mod P==0 ==> (Y-P)^2 mod P==0 ==> (Y^2-2*Y*P+P^2) mod P = Y^2 mod P
34 plt.scatter(X, P-Y)
35 plt.show()
36 
37 I = Image.open(os.path.join('.vscode\Bitmain_Miner_Ref\EEC_Vector_Graph.png'))
38 I.show()
39 
40 # -8除以3的余数:商-3余数1(余数是不能为负数的!)
41 print(-8 % 3)
42 
43 x = np.linspace(-0.7,5,1000)
44 y = np.sqrt(x**3+x+1)
45 
46 plt.xlim(-5,5)
47 plt.ylim(-6,6)
48 plt.plot(x,y)
49 plt.plot(x,-y)
50 plt.show()
51 
52 x = np.linspace(-1,5,1000)
53 y1 = np.sqrt(x**3-x)
54 plt.xlim(-5,5)
55 plt.ylim(-6,6)
56 plt.plot(x,y1)
57 plt.plot(x,-y1)
58 plt.show()

查看代码

3. BTC-地址：

定义：比特币地址是一串数字和字母比特币交易信息有哪些，公钥生成的比特币地址以数字1开头 eg: 1J7mdg5rbQyUHENYdx39WVWK7fsLpEoXZy

比特币地址可以通过一种单向哈希加密算法从公钥中获取：

SHA256() RIPEMD160() SHA160() 1 和 2 合并在一起： SHA160(data) = RIPEDMD(SHA256(data))

BTC-地址生成流程图：

3. 深入剖析BTC区块链技术&区块特性

我们主要分析区块链和区块的相关内容：

4、使用python实现以上相关API和数据结构：

 1 import numpy as np 
 2 # Hash哈希运算库-SHA128 SHA256 MD5
 3 import hashlib
 4 # OepnSSL加密库-EEC椭圆曲线加密函数计算公钥

 5 import OpenSSL
 6 import random
 7 import json
 8 import time
 9 import sys
10 import os
11 
12 max_nonce = 2**32 # 4 billion
13 difficulty_bits = 12
14 target = 2**(256-difficulty_bits)
15 
16 class block:
17         def __init__(self):
18                 self.data = {'Magicno':0xD9B4BEF9, 'Blocksize':0, \
19                              'Blockheader':[0,0,0,0,0,0], 'Transition_counter':0, \
20                              'transitions':[]}
21                 self.edition = 1.0
22                 self.time = 0.0
23                 self.Hash = 0
24                 self.PreHash = 0
25                 self.Nonce = 0
26 
27 def proof_of_work(header):
28         # calc the difficulty target
29         for nonce in range(max_nonce):
30                 temp = header+str(nonce)
31                 hash_result = hashlib.sha256(temp.encode('utf-8')).hexdigest()
32                 print(str(hash_result), end='\r')
33                 # check if this is a valid result,below the target
34                 if int(hash_result,16) < target:
35                         # print("Success with nonce %d" % nonce)
36                         # print("Hash is %s" % hash_result)
37                         return hash_result,nonce
38         print("Failed after %d (max_nonce) tries" % max_nonce)
39 
40 def Self_Hash_Get(PreHash, time, data):
41         header = str(PreHash) + str(time) + str(data)
42         hash_result,nonce = proof_of_work(header)
43         return hash_result,nonce
44 
45 def New_block(transitions, PreBlockHash, block):
46         block.data['Transition_counter'] = len(transitions)
47         block.data['transitions'] = transitions
48         block.data['Blocksize'] = sys.getsizeof(block.data)
49         block.time = time.time()
50         block.PreHash = PreBlockHash
51         hash_result, hash_nonce = Self_Hash_Get(block.PreHash, block.time, block.data)

52         block.Hash = hash_result
53         block.Nonce = hash_nonce
54 
55 def NewGenesisBlock(block):
56         New_block('NewGenesisBlock', b'', block)
57 
58 class block_chain:
59         def __init__(self):
60                 self.block = []
61 
62 chain = block_chain()
63 
64 def AddBlockChain(block,chain):
65         if int(block.Hash, 16) < target:
66                 chain.block.append(block)
67         else:
68                 print('Invalid block!')
69 
70 def CreateBlockChain(chain):
71         Block = block()
72         NewGenesisBlock(Block)
73         AddBlockChain(Block,chain)
74 
75 def GetLastBlockHash(chain):
76         return chain.block[len(chain.block)-1].Hash
77 
78 CreateBlockChain(chain)
79 for i in range(10):
80         transitions = ['Li Send 10BTC to You', 'Ni Get 2BTC from Dian']
81         PreBlockHash = GetLastBlockHash(chain)
82         Block = block()
83         print('Calculating Hash...')
84         New_block(transitions, PreBlockHash, Block)
85         AddBlockChain(Block,chain)
86 
87 for i in range(len(chain.block)):
88         print('Block%d\'HashVal=%s' %(i ,chain.block[i].Hash))

查看代码

运行我们得到的代码，结果如下：（取5个Blocks）

Block的Hash值符合要求，成功加入区块链

5.参考文章

区块链热门漫画介绍参考001：

区块链Go语言实现Step-byStep-Reference002：

加密算法参考003：

BTC捐赠 非常感谢！

3Jvg6ao53eCnj7EgapEa7arxsouLVxxQ4F