区块链基础认识-BTC

1、什么是区块链

a.定义：

从本质上来说区块链就是一种通过将用户的某种特定信息(比如交易信息)，通过很多台计算机记录保存并同步的过程，每个区块都记录了对应的交易信息，将这些交易信息串联起来就形成了所谓的区块链，区块链也就是存储在很多计算机节点中的数据库一样的文件db。

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

从用途上来说，区块链是一套以几乎无法伪造或篡改的方式构建而成的数据存储数学架构，可用于存储各类有价值数据。

b.特点：

• 去中心化：由于使用分布式核算和存储，不存在中心化的硬件或管理机构，任意节点的权利和义务都是均等。
• 去信任：系统中所有节点之间无需信任也可以进行交易，因为数据库和整个系统的运作是公开透明的，在系统的规则和时间范围内，节点之间无法欺骗彼此。
• 开放性：系统是开放的，除了交易各方私有信息被加密外，区块链的数据对所有人公开，任何人都可以通过公开的接口查询区块链数据。
• 自治性：区块链采用基于协商一致的规范和协议,使得整个系统中的所有节点能够在去信任的环境自由安全的交换数据。
• 信息不可篡改：一旦信息经过验证并添加至区块链，就会永久存储，除非能够同时控制住系统中超过51%的节点，否则单个节点上对数据库的修改是无效。
• 匿名性：由于节点之间的交换遵循固定的算法，其数据交互是无需信任的。

c.区块链图示：

2、区块链中BTC的基本组成部分

如下图所示，这是BTC的四大基本组成模块

a.BTC区块链Block Chain:

区块链用来将生成的所有的区块串联起来，区块链的高度表示了当前总共拥有的区块数量，区块链每间隔十分钟就会广播一次，将完成的区块交易信息内容添加到区块链当中，同时给完成区块ID寻找的矿机进行奖励，每格四年，产生区块的矿机奖励的BTC就会减半，因此比特币是收敛币种，不存在通货膨胀的情况(BTC产生情况看下图)，比特币能够维持到2140年的原因是由于比特币系统会根据计算机的算力变化调整挖矿的难度，从而控制了BTC的发行速度！

代码如下：

 import matplotlib.pyplot as plt
 from PIL import Image
 import time
 import sys
 import os

 # 初始奖励50BTC
 start_block_reward = 50
 # 以10分钟为一个区块间隔，210000块=4Year*365Day*24Hour*6，需要4年
 reward_interval = 210000

 Year = []
 Satoshis = []

 def max_money():
         # 50 BTC = 50 0000 0000 Satoshis
         current_reward = 50 * 10**8
         total = 0
         year = 2008
         while current_reward > 0:
                 total += reward_interval * current_reward
                 Satoshis.append(total)
                 current_reward /= 2
                 Year.append(year)
                 year += 4
         return total
 print("Total BTC to ever be created:", max_money(), "Satoshis")
 print("1 BTC = 100000000 Satoshis!")

 plt.xlim((2008,2140))
 plt.plot(Year,Satoshis)
 plt.show()

代码运行结果：

总共2100万个BTC截至2140年

notice：区块链分叉是由于世界范围内的网络状况不同，可能同时有两个区块同时产生了，一个在欧洲A，一个在南美洲B，那么距离节点nodeA近的先收到了A的广播，同样的距离nodeB近的节点先收到了B的广播，因此在两部分结点确认数增多之后，就会发生区块链的分叉，分叉的情况会暂时保存下来，等到下一个区块的出来，甚至下下一个区块的出现，最终区块链长的那一边作为最终的区块链，这样区块链又会收敛到同一个区块链之上，保证了区块链的唯一性。

b.BTC区块Block:

区块Block中存储了当前大部分的交易的内容，那么区块由谁来产生呢，那就是矿工miners(矿机)，矿机通过收集网络节点上的所有的交易信息，根据每一笔交易提供的交易费用来完成优先级排序，交易费越高越容易被快速处理，在确认这些高优先级的交易信息之后，miners将会将这些交易信息进行打包，将打包好的数据存放起来，开始生成区块对应的区块ID(一个很难计算的HASH值)，如若某个miners优先找到了满足要求的HASH-Value，那么它将得到这次的比特币奖励，以及交易收取的手续费。下面简单的看一下如何计算满足要求的HASH值：

代码如下：

 import numpy as np
 # Hash哈希运算库-SHA128 SHA256 MD5
 import hashlib
 import time
 import sys
 import os
 # 工作量证明算法
 max_nonce = 2**32 # 4 billion

 def proof_of_work(header,difficulty_bits):
         # calc the difficulty target
         target = 2**(256-difficulty_bits)
         for nonce in range(max_nonce):
                 temp = str(header)+str(nonce)
                 hash_result = hashlib.sha256(temp.encode('utf-8')).hexdigest()
                 # check if this is a valid result,below the target
                 if int(hash_result,16) < target:
                         print("Success with nonce %d" % nonce)
                         print("Hash is %s" % hash_result)
                         return hash_result,nonce
         print("Failed after %d (max_nonce) tries" % max_nonce)

 Start_time = time.time()
 proof_of_work('Hash_val',22)
 End_time = time.time()
 print('The time cost:', End_time-Start_time, 's')

代码运行结果：

我们可以看到，当难度为22时，计算出一个满足要求的Hash值需要的时间约为6.7s，随着难度的增加，这个时间将会呈指数级增长！

c.BTC交易exchange：

在BTC交易的过程中，我们可以用比特币兑换我们想要的物品，也可以将比特币转移给别人，无论哪一种方式，都需要将指定的BTC输送到对应的钱包的地址上。

在BTC未交易的时候，BTC处于UTXO的状态，这种状态一直被阻塞，直到BTC的所属者通过他的私钥和数字签名释放BTC，完成转账的功能，BTC在完成转账之后可能还会存在找零，找零的BTC又会处于UTXO状态，而接收者的比特币地址，也就是钱包的地址处于的状态时URTX状态，等待对应的转账功能！

相关知识点：数字签名、加密算法

d.BTC钱包Wallet：

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

1、私钥Private-Key：

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

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

 numpy:key = np.random.random()
 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相加)

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

 import matplotlib.pyplot as plt
 from PIL import Image
 import numpy as np
 # Hash哈希运算库-SHA128 SHA256 MD5
 import hashlib
 # OepnSSL加密库-EEC椭圆曲线加密函数计算公钥
 import OpenSSL
 import random
 import time
 import sys
 import os

 # 学习如何使用EEC椭圆曲线加密问题，ECC函数的实现方式等等
 # The ecc function is: (x^3+7) mod P = y^2 mod P
 P = 17
 x= np.linspace(0,P,P,dtype='int')
 y = list()
 for i in x:
     temp = (i**3 + 7) % P
     append_flag = 0
     for j in range(0,P):
         if j**2 % P == temp:
             y.append(j)
             append_flag = 1
             break
     if append_flag == 0:
         y.append(-1)
 Y = np.array(y)
 X = x
 plt.xlim( (0, P) )
 plt.ylim( (0, P) )
 plt.scatter(X, Y)
 # Y^2 mod P==0 ==> (Y-P)^2 mod P==0 ==> (Y^2-2*Y*P+P^2) mod P = Y^2 mod P
 plt.scatter(X, P-Y)
 plt.show()

 I = Image.open(os.path.join('.vscode\Bitmain_Miner_Ref\EEC_Vector_Graph.png'))
 I.show()

 # -8除以3的余数:商-3余数1(余数是不能为负数的!)
 print(-8 % 3)

 x = np.linspace(-0.7,5,1000)
 y = np.sqrt(x**3+x+1)

 plt.xlim(-5,5)
 plt.ylim(-6,6)
 plt.plot(x,y)
 plt.plot(x,-y)
 plt.show()

 x = np.linspace(-1,5,1000)
 y1 = np.sqrt(x**3-x)
 plt.xlim(-5,5)
 plt.ylim(-6,6)
 plt.plot(x,y1)
 plt.plot(x,-y1)
 plt.show()

3、BTC-Address：

定义：比特币地址由数字和字母组成的字符串，由公钥生成的比特币地址以数字1开头 eg：1J7mdg5rbQyUHENYdx39WVWK7fsLpEoXZy

比特币地址可以由公钥通过单向哈希加密算法得到：

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

BTC-Address生成流程图：

3、深入分析BTC中区块链技术 & 区块特性

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

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

 import numpy as np
 # Hash哈希运算库-SHA128 SHA256 MD5
 import hashlib
 # OepnSSL加密库-EEC椭圆曲线加密函数计算公钥
 import OpenSSL
 import random
 import json
 import time
 import sys
 import os

 max_nonce = 2**32 # 4 billion
 difficulty_bits = 12
 target = 2**(256-difficulty_bits)

 class block:
         def __init__(self):
                 self.data = {'Magicno':0xD9B4BEF9, 'Blocksize':0, \
                              'Blockheader':[0,0,0,0,0,0], 'Transition_counter':0, \
                              'transitions':[]}
                 self.edition = 1.0
                 self.time = 0.0
                 self.Hash = 0
                 self.PreHash = 0
                 self.Nonce = 0

 def proof_of_work(header):
         # calc the difficulty target
         for nonce in range(max_nonce):
                 temp = header+str(nonce)
                 hash_result = hashlib.sha256(temp.encode('utf-8')).hexdigest()
                 print(str(hash_result), end='\r')
                 # check if this is a valid result,below the target
                 if int(hash_result,16) < target:
                         # print("Success with nonce %d" % nonce)
                         # print("Hash is %s" % hash_result)
                         return hash_result,nonce
         print("Failed after %d (max_nonce) tries" % max_nonce)

 def Self_Hash_Get(PreHash, time, data):
         header = str(PreHash) + str(time) + str(data)
         hash_result,nonce = proof_of_work(header)
         return hash_result,nonce

 def New_block(transitions, PreBlockHash, block):
         block.data['Transition_counter'] = len(transitions)
         block.data['transitions'] = transitions
         block.data['Blocksize'] = sys.getsizeof(block.data)
         block.time = time.time()
         block.PreHash = PreBlockHash
         hash_result, hash_nonce = Self_Hash_Get(block.PreHash, block.time, block.data)
         block.Hash = hash_result
         block.Nonce = hash_nonce

 def NewGenesisBlock(block):
         New_block('NewGenesisBlock', b'', block)

 class block_chain:
         def __init__(self):
                 self.block = []

 chain = block_chain()

 def AddBlockChain(block,chain):
         if int(block.Hash, 16) < target:
                 chain.block.append(block)
         else:
                 print('Invalid block!')

 def CreateBlockChain(chain):
         Block = block()
         NewGenesisBlock(Block)
         AddBlockChain(Block,chain)

 def GetLastBlockHash(chain):
         return chain.block[len(chain.block)-1].Hash

 CreateBlockChain(chain)
 for i in range(10):
         transitions = ['Li Send 10BTC to You', 'Ni Get 2BTC from Dian']
         PreBlockHash = GetLastBlockHash(chain)
         Block = block()
         print('Calculating Hash...')
         New_block(transitions, PreBlockHash, Block)
         AddBlockChain(Block,chain)

 for i in range(len(chain.block)):
         print('Block%d\'HashVal=%s' %(i ,chain.block[i].Hash))

运行我们所得到的代码，结果如下：(取了5个Block)

Block的Hash值都满足要求，并成功加入了区块链中

5、参考文章

区块链通俗漫画介绍Reference001：https://www.cnblogs.com/behindman/p/8873191.html

区块链Go语言实现Step-byStep-Reference002：https://liuchengxu.gitbook.io/blockchain/

加密算法Reference003：https://www.cnblogs.com/songwenlong/p/5944139.html#4160452

BTC Donation Thanks a lot！

3Jvg6ao53eCnj7EgapEa7arxsouLVxxQ4F