什么是比特币？对于风靡全球的比特币，你是否好奇过它到底是什么原理？

---

一、什么是比特币

比特币是由一系列概念和技术作为基础构建的数字货币生态系统。

狭义的“比特币”代表系统中的货币单位，用于储存和传输价值。用户主要通过互联网使用比特币系统，当然其他网络也可以使用。比特币协议以各种开源软件的形式实现，这些软件可以在笔记本电脑、智能手机等多种设备上运行，让用户方便地接入比特币系统。

不同于传统货币，比特币是完全虚拟的。它不但没有实体，本质上也没有一种虚拟物品代表比特币。比特币隐含在收发币的转账记录中。用户只要有证明其控制权的密钥，用密钥解锁，就可以发送比特币。这些密钥通常存储在计算机的数字钱包里。拥有密钥是使用比特币的唯一条件，这让控制权完全掌握在每个人手中。

比特币是一个分布式的点对点网络系统。因此没有“中央”服务器，也没有中央发行机构。

比特币是通过“挖矿”产生的，挖矿就是验证比特币交易的同时参与竞赛来解决一个数学问题。任何参与者（比如运行一个完整协议栈的人）都可以做矿工，用他们的电脑算力来验证和记录交易。平均每10分钟就有人能验证过去这10分钟发生的交易，他将会获得新币作为工作回报。

比特币协议规定，每四年新币的开采量减半，同时限制比特币的最终开采总量为2,100万枚。这样，流通中的比特币数量非常接近一条曲线，并将在2140年比特币将达到2,100万枚。由于比特币的开采速度随时间递减，从长期来看，比特币是一种通货紧缩货币。此外，不能通过“印刷”新比特币来实现“通货膨胀”。

比特币是一种协议、一种网络、一种分布式计算创新的代名词。比特币是这种创新的首次实际应用。

比特币代表了数十年的密码学和分布式系统的巅峰之作，这是一个独特而强大的组合，汇集了四个关键的创新点。比特币由这些构成：

• 一个去中心化的点对点网络（比特币协议）
• 一个公共的交易账簿（区块链）
• 一个去中心化的数学的和确定性的货币发行（分布式挖矿）
• 一个去中心化的交易验证系统（交易脚本）

通俗的讲比特币就是一种基于分布式网络的数字货币，没有发行中心，总量恒定，并加入了4年减半，pow挖矿共识等机制，而且实行了账本公开、交易全网验证模式，让交易变的更公开化、为防止多重支付问题， 加入了以最长链为共识机制验证交易。这一系列的规则，让比特币的变的更独特，从而让比特币的价值也变的更大。

关于什么是比特币，可能每个人的理解都不同，从中本聪的白皮书中可以得知，比特币的本质是：一个纯粹的点对点版本的电子现金系统，本质是一个可以转账的手段，并且不通过金融机构，面对支付商业 上的亿万流通，中本聪说："我们真正需要的是一种基于加密证明而非基于信任的电子支付系统，允许任意双方在不需要信任第三方的情况下直接交易。"从而解决中间商问题，杜绝虚假信息，真正达到点对点交易，仿佛回到了 物物交换时代，只不过比特币的模式让交易更方便而已。

二、什么是挖矿？

挖矿是消耗计算资源来处理交易，确保网络安全以及保持网络中每个人的信息同步的过程。它可以理解为是比特币的数据中心，区别在于其完全去中心化的设计， 矿工在世界各国进行操作，没有人可以对网络具有控制权。这个过程因为同淘金类似而被称为“挖矿”，因为它也是一种用于发行新比特币的临时机制。

然而，与淘金不同的是，比特币挖矿对那些确保安全支付网络运行的服务提供奖励。

任何人均可以在专门的硬件上运行软件而成为比特币矿工。挖矿软件通过P2P网络监听交易广播，执行恰当的任务以处理并确认这些交易。

比特币矿工完成这些工作能赚取用户支付的用于加速交易处理的交易手续费以及按固定公式增发的比特币

新的交易需要被包含在一个具有数学工作量证明的区块中才能被确认。这种证明很难生成因为它只能通过每秒尝试数十亿次的计算来产生。 矿工们需要在他们的区块被接受并拿到奖励前运行这些计算。随着更多的人开始挖矿，寻找有效区块的难度就会由网络自动增加以确保找到区块的平均时间保持在10分钟。 因此，挖矿的竞争非常激烈，没有一个个体矿工能够控制块链里所包含的内容。

三、什么是去中心化

“去中心化”是一种现象或结构，其只能出现在拥有众多用户或众多节点的系统中，每个用户都可连接并影响其他节点。通俗地讲，就是每个人都是中心， 每个人都可以连接并影响其他节点，这种扁平化、开源化、平等化的现象或结构，称之为“去中心化”。

同时“去中心化”是区块链的典型特征之一，其使用分布式储存与算力，整个网络节点的权利与义务相同，系统中数据本质为全网节点共同维护， 从而区块链不再依靠于中央处理节点，实现数据的分布式存储、记录与更新。而每个区块链都遵循统一规则，该规则基于密码算法而不是信用证书， 且数据更新过程都需用户批准，由此奠定区块链不需要中介与信任机构背书。

四、什么是区块链？

区块链就是很多的区块按一定顺序连接。这些区块分散地存储在世界各地的电脑主机中，也就是“分布式”特征。虽然这些单个计算机都是处在风险环境中，但是因为数据分布在无数个主机中，这就保证了数据是不能少数人控制或者篡改的。

每一个区块都是一个数据集。 区块之间的连接方式采用密码学中的哈希函数。哈希函数有一个特点，就是它是非对称的。例如一串数据经过哈希函数处理变成另一数据，这个过程是很简单的。但是通过结果却很难还原出原来的数据。而且即使稍微对原数据做出一点改动， 在经过哈希处理后这些微小的差异会被放大很多， 轻易就可以被其他人发现异常之处。这保证了区块链参与者都可以对交易进行验证而无法篡改交易数据，极大地提升了加密的安全性。

后一个区块指向前一个区块。有一点比较有意思，不同参与者的区块可能是不一样的，区块顺序等都会不同。

• 区块是一块存储空间，可以存储数据
• 区块链不但像链表一样把区块串起来，还有约定了一系列的方法管理这些数据，所以它是存储系统
• 区块链有很多节点，每个节点都保存了全部的数据，所以它是高可用的
• 每一个中心节点都可以生成区块，并写入数据，所以每一个点都是中心节点，或者说区块链是去中心化的，要想控制整个系统，必须控制一半以上的节点，才能控制投票，于是这个系统没有管理员

综上，区块链实际上是一个没有管理员的，去中心化的，每个节点都拥有全部数据的分布式存储系统。只要你愿意，你随时可以成为区块链中的一个节点，并参与区块的生成与写入，比特币就是基于这个分布式存储上的电子货币。

五、比特币与区块链的关系？

有区块链技术才有比特币，区块链是密码学技术，p2p技术等技术柔和一起达成一共共识机制，形成一种分布式账本， 使得每一个参与者都有平等记账机会，防止链上篡改，让经济体不在单一化，通过这种信任机制创造出可信任的一条跑在计算机上的链， 使用共识防止出现攻击现象。

在区块链上运行的同时密码学技术创造一种价值产物，就是比特币，所谓挖矿，只是用来证明谁的记账更多，任 何节点都有权收集最新的交易记录放到一个区块中，然后把这个区块提交投票审核。

六、部分技术展示

Go语言实现pow协议

• Proof of Work 工作量证明。字面意思，就是谁做的活越多，谁话事权越大，一定层面上类似现实生活的多劳多得的概念。

举例说明

1. 拿比特币为例子，比特币挖矿就是通过计算符合某一个比特币区块头的哈希散列值争夺记账权。这个过程需要通过大量的计算实现，简单理解就是你进行的计算量大（工作量大），你就有大概率获得记账权，即矿工的挖出的区块并入主链。
2. 区块头，区块链中的区块的头部。你有一个饭盒，饭盒第一层，形象为动物头部，称之为头部。第一层放着米饭，米饭就是头部装载着的东西，哈希散列值，一种通过数学公式计算得出的值。
3. 哈希：数学中的散列函数
4. 散列值: 通过哈希函数得出的值
5. 例如加法公式：1 + 2 = 3。那么哈希公式：hash(1,2) = 结果
6. 区块头的哈希散列值，饭盒第一层装着的是饭。那么这里的这个值就是区块头装着的东西。记账权，话事权，谁挖出的区块是有效的。

Golang 实现PoW协议

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/gorilla/mux"
	"github.com/joho/godotenv"

)

/*
	新建 .env ，添加 ADDR=9000
	新建 main.go，引入相应的包

	go run main.go 启动当前服务 控制台打印出如下消息

	2020/01/01 14:05:28 Listening on  9000
	(main.Block) {
	 Index: (int) 0,
	 Timestamp: (string) (len=51) "2020-01-01 14:05:28.320064 +0800 CST m=+0.000794081",
	 BPM: (int) 0,
	 Hash: (string) (len=64) "f1534392279bddbf9d43dde8701cb5be14b82f76ec6607bf8d6ad557f60f304e",
	 PrevHash: (string) "",
	 Difficulty: (int) 1,
	 Nonce: (string) ""
	}
	// 使用curl 请求生成新的区块
	curl -d '{"BMP": 20}' http://localhost:9000

	53a7710028d4aee15bcf06918508aa0107387a9432018089f6c507b8e1230045  do more work!
	d19f8f83b7e315126ba341ab1cc7d1d75acbbedde48e2a619fc70958a8f1cd16  do more work!
	c5d959b91b8d62a13ff4c153ea87b150a1fa2b7df17901b3bd67bae288296fe6  do more work!
	f21e06d0c3fd40d44dc9aac5b3acbbe768b9c223233da1ca63e1ffd1cf837b26  do more work!
	b1f09c6d3853af434001755f9c51f3477ff8fb42beafe836de4f21b3e5bd804b  do more work!
	ece1a6aa8d28f08806e5452bd4a418b8517525a0f96798d87e38f3015320da0c  do more work!
	fd18e42806c63e91fc674430e3e4c9d62662630823fff6844db16ce5abcf5d53  do more work!
	19e96095db4136996e4962e68002ee1cc053771c6496c389f6337e0abd3ba826  do more work!
	...
	// 查看当前已经生成的区块
	浏览器访问：http://localhost:9000

 */
// 代表难度系数，如果赋值为 1，则需要判断生成区块时所产生的 Hash 前缀至少包含1个 0
const difficulty = 1

/*

	Block 代表区块的结构体。

	Index 是区块链中数据记录的位置

	Timestamp 是自动确定的，并且是写入数据的时间

	BPM 是每分钟跳动的次数，是你的脉率

	Hash 是代表这个数据记录的SHA256标识符

	PrevHash 是链中上一条记录的SHA256标识符

	Difficulty 是当前区块的难度系数
	Nonce 是 PoW 挖矿中符合条件的数字
	Blockchain 是存放区块数据的集合
	Message 是使用 POST 请求传递的数据
	mutex 是为了防止同一时间产生多个区块
*/

//声明区块
type Block struct {
	Index      int
	Timestamp  string
	BPM        int
	Hash       string
	PrevHash   string
	Difficulty int
	Nonce      string
}

var Blockchain []Block

type Message struct {
	BPM int
}

var mutex = &sync.Mutex{}

//生成区块
func generateBlock(oldBlock Block, BPM int) Block {
	var newBlock Block

	t := time.Now()

	newBlock.Index = oldBlock.Index + 1
	newBlock.Timestamp = t.String()
	newBlock.BPM = BPM
	newBlock.PrevHash = oldBlock.Hash
	newBlock.Difficulty = difficulty

	for i := 0; ; i++ {
		hex := fmt.Sprintf("%x", i)
		newBlock.Nonce = hex
		if !isHashValid(calculateHash(newBlock), newBlock.Difficulty) {
			fmt.Println(calculateHash(newBlock), " do more work!")
			time.Sleep(time.Second)
			continue
		} else {
			fmt.Println(calculateHash(newBlock), " work done!")
			newBlock.Hash = calculateHash(newBlock)
			break
		}

	}
	return newBlock
}
//判断产生的哈希值是否合法
func isHashValid(hash string, difficulty int) bool {
	//复制 difficulty 个0，并返回新字符串，当 difficulty 为2 ，则 prefix 为 00
	prefix := strings.Repeat("0", difficulty)
	// HasPrefix判断字符串 hash 是否包含前缀 prefix
	return strings.HasPrefix(hash, prefix)
}
// 根据设定的规则，生成 Hash 值
func calculateHash(block Block) string {
	record := strconv.Itoa(block.Index) + block.Timestamp + strconv.Itoa(block.BPM) + block.PrevHash + block.Nonce
	h := sha256.New()
	h.Write([]byte(record))
	hashed := h.Sum(nil)
	return hex.EncodeToString(hashed)
}

// 验证区块
func isBlockValid(newBlock, oldBlock Block) bool {
	if oldBlock.Index+1 != newBlock.Index {
		return false
	}

	if oldBlock.Hash != newBlock.PrevHash {
		return false
	}

	if calculateHash(newBlock) != newBlock.Hash {
		return false
	}

	return true
}

// web服务器

func run() error {
	mux := makeMuxRouter()
	httpAddr := os.Getenv("ADDR")
	log.Println("Listening on ", os.Getenv("ADDR"))
	s := &http.Server{
		Addr:           ":" + httpAddr,
		Handler:        mux,
		ReadTimeout:    10 * time.Second,
		WriteTimeout:   10 * time.Second,
		MaxHeaderBytes: 1 << 20,
	}

	if err := s.ListenAndServe(); err != nil {
		return err
	}

	return nil
}

func makeMuxRouter() http.Handler {
	muxRouter := mux.NewRouter()
	muxRouter.HandleFunc("/", handleGetBlockchain).Methods("GET")
	muxRouter.HandleFunc("/", handleWriteBlock).Methods("POST")
	return muxRouter
}

// handleGetBlockchain 获取所有区块的列表信息

func handleGetBlockchain(w http.ResponseWriter, r *http.Request) {
	bytes, err := json.MarshalIndent(Blockchain, "", "  ")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	io.WriteString(w, string(bytes))
}

// 生成新的区块
func handleWriteBlock(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	var m Message

	decoder := json.NewDecoder(r.Body)
	if err := decoder.Decode(&m); err != nil {
		respondWithJSON(w, r, http.StatusBadRequest, r.Body)
		return
	}
	defer r.Body.Close()

	//ensure atomicity when creating new block
	mutex.Lock()
	newBlock := generateBlock(Blockchain[len(Blockchain)-1], m.BPM)
	mutex.Unlock()

	if isBlockValid(newBlock, Blockchain[len(Blockchain)-1]) {
		Blockchain = append(Blockchain, newBlock)
		spew.Dump(Blockchain)
	}

	respondWithJSON(w, r, http.StatusCreated, newBlock)

}
// 返回json格式
func respondWithJSON(w http.ResponseWriter, r *http.Request, code int, payload interface{}) {
	w.Header().Set("Content-Type", "application/json")
	response, err := json.MarshalIndent(payload, "", "  ")
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("HTTP 500: Internal Server Error"))
		return
	}
	w.WriteHeader(code)
	w.Write(response)
}

func main() {
	// 根目录的文件 .env 读取相应的变量
	err := godotenv.Load()
	if err != nil {
		log.Fatal(err)
	}

	go func() {
		t := time.Now()
		// 创建初始区块
		genesisBlock := Block{}
		genesisBlock = Block{0, t.String(), 0, calculateHash(genesisBlock), "", difficulty, ""}
		spew.Dump(genesisBlock)

		mutex.Lock()
		Blockchain = append(Blockchain, genesisBlock)
		mutex.Unlock()
	}()
	// 启动web服务
	log.Fatal(run())

}