leaf

liangpeili@LiangXiaoxin:~$ echo 'aschplatform' | md5sum
150fa3630db1d8f576d1266176f6e0f7  -
liangpeili@LiangXiaoxin:~$ echo 'aschplatform1' | md5sum
e915a617b2301631ec14d1ca2c093c63  -
liangpeili@LiangXiaoxin:~$ echo 'aschplatform2' | md5sum
bbb9d830f4a5d47051f9fd19cb0fc75e  -

#!/usr/bin/env python
#coding:utf-8
example of proof-of-work algorithm

import hashlib
import time

max_nonce = 2 ** 32 # 4 billion

def proof_of_work(header, difficulty_bits):

calculate the difficulty target

target = 2 ** (256-difficulty_bits)

for nonce in xrange(max_nonce):
hash_result = hashlib.sha256(str(header)+str(nonce)).hexdigest()

# check if this is a valid result, below the target
  if long(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" % nonce)
return nonce
if name == "main":
nonce = 0
hash_result = ''

difficult from 0 to 15 bits

for difficulty_bits in xrange(16):

difficulty = 2 ** difficulty_bits
print("Difficulty: %ld (%d bits)" %(difficulty, difficulty_bits))

print("Starting search...")

# checkpoint the current time
start_time = time.time()

# make a new block which includes the hash from the previous block
# we fack a block of transactions - just a string
new_block = 'test block with transactions' + hash_result
# find a valid nonce for the new block
(hash_result, nonce) = proof_of_work(new_block, difficulty_bits)

# checkpoint how long it took to find a result 
end_time = time.time()

elapsed_time = end_time - start_time
print("Elapsed Time: %.4f seconds" % elapsed_time) 

if elapsed_time > 0:

  # estimate the hashes per second
  hash_power = float(long(nonce)/elapsed_time)
  print("Hashing Power: %ld hashes per second" % hash_power)  

2.數字簽名

在現實工作和生活中，我們使用簽名的方式表達了對一份文件的認可，其他人可以識別出你的簽名並且無法偽造你的簽名。數字簽名就是對現實簽名的一種電子實現，它不僅可以完全達到現實簽名的特點，甚至能做得更好。常用的數字簽名算法有RSA（Rivest-Shamir-Adleman Scheme）、DSS（Digital Signature Standard）等。比特幣使用ECDSA（椭圆曲线数字签名算法）來生成賬戶的公私鑰以及對交易和區塊進行驗證數字簽名的工作原理如下所示：

1）Alice生成一對密鑰，一個是sk（signing key），是非公開的；另一個是vk（verification key），是公開的。這一對密鑰同時生成，並且在數學上是相互關聯的，同時，根據vk無法推測出關於sk的任何信息。

2）數字簽名算法接收兩個輸入：信息M和sk，生成一個數字簽名Sm。

3）驗證函數接收信息M、Sm以及vk作為輸入，返回的結果是yes或者no。這一步的目的是為了驗證你看到的針對信息M的數字簽名確實是由Alice的sk來簽發的，用於確認信息與簽名是否相符。

與手寫簽名不同，手寫簽名基本都是相似的，但是數字簽名卻受輸入影響很大。對輸入的輕微改變都會產生一個完全不同的數字簽名。一般不會直接對信息進行數字簽名，而是對信息的哈希值進行簽名。由加密哈希函數的無碰撞性可知，這樣和對原信息進行簽名一樣安全。

3.共識機制

區塊鏈可以看做是一本記錄所有交易的分佈式公開賬簿，而區塊鏈中每個節點都是對等的。這就帶來一個問題：誰有權往這個賬本錄入數據？如果有好幾個節點同時對區塊鏈進行數據寫入，最終以誰的為準？這就是在分佈式網絡中如何保持數據一致性的问题。共識機制是指在一個分佈式的網絡中，讓各個參與網絡的節點達成數據上的一致性。在區塊鏈中，共識機制的作用還包括區塊生產、區塊驗證以及系統的經濟激勵等功能。

不同的共識機制適用於不同的應用場景，以下是常用的共識機制及其適用的應用場景介紹：

工作量證明（Proof of Work，POW）——比特幣使用的就是工作量證明的共識機制。在這種機制裡，任何擁有計算能力的設備都可以參與競爭區塊的生產，系統會根據當前全網的算力動態調整難度值，來保證平均每10分鐘網絡將根據後續區塊的態度來決定認可哪個區塊。一般來說，一筆交易在經過6次確認（約1個小時）後被認為是比較安全而且不可逆的。中本聰在設計比特幣時，使用工作量證明機制背後的核心思想是“one cpu one vote”，期望能夠把比特幣設計成一個完全去中心化的系統，任何人都可以使用電腦等終端參與進來。雖然後來由於礦池的出現，使得比特幣系統的算力比較集中，但目前工作量證明機制仍然被認為是最適合公鏈的共識機制。

·股權證明（Proof of Stake，POS）——股權證明機制於2013年被提出，最早應用於Peercoin中。在工作量證明機制中，生產區塊的概率和你擁有的算力成正比。相應的，在股權證明機制中，生產區塊的難度和你在該系統中占有的股權成正比。在股權證明機制中，一個區塊的生產過程為：節點通過保證金（代幣、資產、名聲等具備價值屬性的物品即可）來對賭一個合法的區塊會成為新的區塊，其收益為抵押資本的利息和交易服務費。提供的保證金越多，獲得記帳權的概率就越大。一旦生產了一個新的區塊，節點就可以獲得相應的收益。股權證明機制的目標是為了解決工作量證明機制裡大量能源被浪費的問題。惡意參與者存在保證金被罰沒的風險。

·授權股權證明（Delegated Proof of Stake，DPOS）——工作量證明和股權證明機制雖然都可以解決區塊鏈數據的一致性問題，但正如上面提到的工作量證明機制存在算力集中（礦池）的问题，而股權證明機制根據保證金的數量來調節生產區塊難度的方式則會導致“馬太效應”的出現，也就是擁有大量代幣的賬戶權利會越來越大，有可能支配記帳權。為了解決前兩者的問題，後來又有人提出了基於股權證明機制的改進算法——授權股權證明機制。在這種共識機制裡，系統中的每個持幣用戶都可以投票給某些代表，最終得票率在前101名的代表可以獲得系統的記帳權。這些代表按照既定時間來鍛造區塊，並且獲取鍛造區塊的收益。授權股權證明機制既可以提高共識的效率（相較於比特幣每10分鐘生產一個區塊，這種機制可以實現10秒以內生產一個區塊），又避免了能源的浪費和馬太效應，因此成為了很多新興公鏈（比如EOS）的選擇。

4.交易的區塊鏈

在比特幣網絡中，每筆交易完成後，這筆交易會廣播到比特幣的P2P網絡。礦工不僅能夠接收到這筆交易，而且還能接收到相同時間段內其他的所有未被記錄的交易。礦工的工作就是把這些所有交易打包成一個交易區塊。具體的過程是：

1）礦工會把這些交易記錄兩兩配對，通過默克爾樹計算出根節點的值。

2）根節點和上一個區塊的哈希值結合，作為一個Challenge String，供礦工作為工作量證明的輸入值。

3）礦工完成工作量證明，並把proof公開出去供其他節點驗證。同時在第一條記錄（這條記錄也稱為coinbase transaction）裡給自己分配挖礦獎勵。

4）其他節點驗證通過，該區塊作為新區塊加入到區塊鏈中。

5）礦工也可以收集其他交易記錄裡的交易費分配給自己。

比特幣的誕生和區塊鏈技術的不斷發展給我們巨大的想像力。目前，互聯網完成了信息的傳遞，而區塊鏈技術或許可以為互聯網帶來價值的傳遞。區塊鏈技術的基礎設施、應用場景或許還需要一定的時間才可以發展到目前互聯網技術的水平，但是區塊鏈技術的潛力卻不容小覷。用300行代碼開發一個區塊鏈系統
本節使用Node.js來實現一個簡單的區塊鏈系統，只需300行代碼。
區塊和區塊鏈的創建
區塊鏈是把區塊用哈希指針連接起來的鏈條，區塊是其中的基本單位。這裡我們從設計一個區塊的數據結構開始。

1.創建區塊

區塊是構建區塊鏈的基本單位，一個區塊至少要包含以下信息。

·index：區塊在區塊鏈中的位置。

·timestamp：區塊產生的時間。

·transactions：區塊包含的交易。

·previousHash：前一個區塊的Hash值。

·hash：當前區塊的Hash值。

其中，最後兩個屬性previousHash和hash是區塊鏈的精華所在，區塊鏈的不可篡改特性正是由這兩個屬性來保證的。

根據上面的信息，我們來創建一個Block類

const SHA256 = require('crypto-js/sha256');

class Block {
  // 構造函數
  constructor(index, timestamp) {
    this.index = index;
    this.timestamp = timestamp;
     this.transactions = [];
    this.previousHash = '';
    this.hash = this.calculateHash();
  }
  // 計算區塊的哈希值
  calculateHash() {
    return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.transactions) + this.nonce).toString();    
  }
  // 添加新的交易到當前區塊
  addNewTransaction(sender, recipient, amount) {
    this.transactions.push({
      sender,
      recipient,
      amount
    })
  }
  // 查看當前區塊裡的交易信息
  getTransactions() {
    return this.transactions;
  }
}

  在上面的Block類的實現中，我們實用了crypto-js裡的SHA256來作為區塊的哈希算法，這也是比特幣中使用的哈希算法。transactions是一系列交易對象的列表，其中包含的每筆交易的格式為：

{
  sender: sender,
  recipient: recipient,
  amount: amount
}

另外我們給Block類添加了三個方法：calculateHash、addNewTransaction、get-Transactions，分別用來計算當前區塊哈希、增加新交易到當前區塊、獲取當前區塊所有交易。

區塊構建完成後，下一步就是考慮如何把區塊組裝成一個區塊鏈了。

2.創建區塊鏈

一個區塊鏈就是一個鏈表，鏈表中的每個元素都是一個區塊。區塊鏈需要一個創世區塊（Genesis Block）來進行初始化，這也是區塊鏈的第一個區塊，需要手工生成。在我們創建Blockchain類時，需要考慮到創世區塊的生成。以下是代碼示例：

class Blockchain {
  constructor() {
    this.chain = [this.createGenesisBlock()];
  }
  // 創建創始區塊
  createGenesisBlock() {
    const genesisBlock = new Block(0, "01/10/2017");
    genesisBlock.previousHash = '0';
    genesisBlock.addNewTransaction('Leo', 'Janice', 520);
    return genesisBlock;
  }
  // 獲取最新區塊
  getLatestBlock() {
    return this.chain[this.chain.length - 1];
  }
  // 添加區塊到區塊鏈
  addBlock(newBlock) {
    newBlock.previousHash = this.getLatestBlock().hash;
    newBlock.hash = newBlock.calculateHash();
    this.chain.push(newBlock);
  }
  // 驗證當前區塊鏈是否有效
  isChainValid() {
    for (let i = 1; i < this.chain.length; i++){
      const currentBlock = this.chain[i];
      const previousBlock = this.chain[i - 1];

      // 驗證當前區塊的 hash 是否正確

if(currentBlock.hash !== currentBlock.calculateHash()){
        return false;
      }

      // 驗證當前區塊的 previousHash 是否等於上個區塊的 hash
      if(currentBlock.previousHash !== previousBlock.hash){
        return false;
      }
    }
    return true;
  }
}

在Blockchain這個類中，我們實現了一個創建創世區塊的方法。由於創世區塊中並沒有前一個區塊，因此previousHash設置為0。另外假定這一天是Leo和Janice的結婚紀念日，Leo給Janice轉帳520個代幣，由此產生了一筆交易並記錄到創世區塊中。最後我們把這個創世區塊添加到構造函數中，這樣區塊鏈就包含一個創世區塊了。方法getLatestBlock和addBlock含義比較明顯，含義分別是獲取最新區塊和往區塊鏈中添加新的區塊。最後一個isChainValid方法是通過驗證區塊的哈希值來驗證整個區塊鏈是否有效，如果已經添加到區塊鏈的區塊數據被篡改，那麼該方法則返回為false。我們會在下一部分對此場景進行驗證。

3.對區塊鏈進行測試

到現在為止，我們已經實現了一個最簡單的區塊鏈了。在這一部分，我們會對創建的區塊鏈進行測試。方法是向區塊鏈中添加兩個完整的區塊，並且通過嘗試修改區塊內容來展示區塊鏈的不可篡改的特性。

我們先創建一個名字叫作testCoin的區塊鏈。使用Blockchain類新建一個對象，此時它應該只包含創世區塊：

const testCoin = new Blockchain();
console.log(JSON.stringify(testCoin.chain, undefined, 2));

運行該程序，結果為：

[
  {
    "index": 0,
    "timestamp": "01/10/2017",
    "transactions": [
      {
        "sender": "Leo",
        "recipient": "Janice",
        "amount": 520
      }
    ],
    "previousHash": "0",
    "hash": "23975e8996cd37311c7fd0907f9b2511c3bf23cf9c9147cca329dec76d7b544e"
  }
]

然後，我們新建兩個區塊，每個區塊裡都包含一筆交易。然後把這兩個區塊依次添加到testCoin這個區塊鏈上：

lock1 = new Block('1', '02/10/2017');
block1.addNewTransaction('Alice', 'Bob', 500);
testCoin.addBlock(block1);

block2 = new Block('2', '03/10/2017');
block2.addNewTransaction('Jack', 'David', 1000);
testCoin.addBlock(block2);
console.log(JSON.stringify(testCoin.chain, undefined, 2));

可以得到以下結果：


  {
    "index": 0,
    "timestamp": "01/10/2017",
    "transactions": [
      {
        "sender": "Leo",
        "recipient": "Janice",
        "amount": 520
      }
    ],
    "previousHash": "0",
    "hash": "23975e8996cd37311c7fd0907f9b2511c3bf23cf9c9147cca329dec76d7b544e"
  },
  {
    "index": "1",
    "timestamp": "02/10/2017",
    "transactions": [
      {
        "sender": "Alice",
        "recipient": "Bob",
        "amount": 500
      }
    ],
    "previousHash": "23975e8996cd37311c7fd0907f9b2511c3bf23cf9c9147cca329dec76d7b544e",
    "hash": "32b96fa0bba9a7353e67498d822fb0c1f89c307098295c288459cb44dbc5d0f1"
  },
  {
    "index": "2",
    "timestamp": "03/10/2017",
    "transactions": [
      {
        "sender": "Jack",
        "recipient": "David",
        "amount": 1000
      }
    ],
    "previousHash": "32b96fa0bba9a7353e67498d822fb0c1f89c307098295c288459cb44dbc5d0f1",
    "hash": "3a0b9a0471bb474f7560968f2f05ff93306cfc26be7f854a36dc4fea92018db2"
  }
]

testCoin現在包含三個區塊，除了創世區塊以外，剩下的兩個區塊是我們剛剛添加的。注意每一個區塊的previousHash屬性是否正確地指向了前一個區塊的哈希值。

此時我們使用isChainValid方法可以驗證該區塊鏈的有效性。console.log（testCoin.isChainValid（））的返回結果為true。

區塊鏈的防篡改性體現在哪裡呢？我們先來修改第一個區塊的交易。在第一個區塊中，Alice向Bob轉帳500元，假設Alice後悔了，她只想付100元給Bob，於是修改交易信息如下：

block1.transactions[0].amount = 100;
console.log(block1.getTransactions())

Alice查看區塊鏈的交易信息，發現已經改成了100元，放心地走了。Bob看到後，發現交易遭到了篡改。於是Bob開始收集證據，他怎麼證明block1的那筆交易是被人為篡改後的交易呢？Bob可以調用isChainValid方法來證明目前的testCoin是無效的。因為testCoin.isChainValid（）返回值為false。但是testCoin.isChainValid（）為什麼會返回false呢？我們來看一下背後的邏輯：首先Alice修改了交易的內容，這個時候block1的哈希值肯定和通過之前交易計算出的哈希值是不同的。這兩個值的不同會觸發isChainValid返回為false，也就是如下代碼實現的功能：

if(currentBlock.hash !== currentBlock.calculateHash())
{
  return false;
}

既然如此，Alice在修改交易內容的同時修改block1的hash不就可以了嗎？Alice可以繼續篡改其他的區塊內容：

block1.transactions[0].amount = 100;
block1.hash = block1.calculateHash();
console.log(testCoin.isChainValid())
這樣的話，最後的結果依然是false。為什麼呢？是因為下面這段代碼：

if(currentBlock.previousHash !== previousBlock.hash){
  return false;
}
每一個區塊都存儲了上個區塊的哈希值，只修改一個區塊是不夠的，還需要修改下一個區塊存儲的previousHash。如果我們已經安全地存儲了block2的哈希值，那無論如何Alice都是不可能在不被發現的情況下篡改已有數據的。在真實的區塊鏈項目中，修改一個區塊必須修改接下來該區塊之後的所有區塊，這也是無法辦到的事情。區塊鏈的這個“哈希指針”的特性，保證了區塊鏈數據的不可篡改性。

class Block {
  constructor(index, timestamp) {
    this.index = index;
    this.timestamp = timestamp;
    this.transactions = [];
    this.previousHash = '';
    this.hash = this.calculateHash();
    this.nonce = 0;
  }
  ...
}

mineBlock(difficulty) {
    console.log(`Mining block ${this.index}`);
    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
        this.nonce++;
        this.hash = this.calculateHash();
    }
    console.log("BLOCK MINED: " + this.hash);
  }

constructor() {
    this.chain = [this.createGenesisBlock()];
    this.difficulty = 2;
  }

addBlock(newBlock) {
    newBlock.previousHash = this.getLatestBlock().hash;
    newBlock.mineBlock(this.difficulty);
    this.chain.push(newBlock);
  }

block1 = new Block('1', '02/10/2017');
block1.addNewTransaction('Alice', 'Bob', 500);
testCoin.addBlock(block1);

console.log(block1)

Mining block 1
BLOCK MINED: 005fed00324fcbe1f0ab1703afe94e45a99e197a7df142e669444687f9513e57
Block {
  index: '1',
  timestamp: '02/10/2017',transactions: [ { sender: 'Alice', recipient: 'Bob', amount: 500 } ],
  previousHash: '31b15cc32d6772f237dcf298d5b7a2417f298f40ce6d8d5fbe07958141df7a4c',
  hash: '005fed00324fcbe1f0ab1703afe94e45a99e197a7df142e669444687f9513e57',
  nonce: 419 
      }

Mining block 1
BLOCK MINED: 000b7f17beaf58bc8fea996a9fed11103ed27ad6d63818b87d89a440cd9757b5
Block {
  index: '1',
  timestamp: '02/10/2017',
  transactions: [ { sender: 'Alice', recipient: 'Bob', amount: 500 } ],
  previousHash: '31b15cc32d6772f237dcf298d5b7a2417f298f40ce6d8d5fbe07958141df7a4c',
  hash: '000b7f17beaf58bc8fea996a9fed11103ed27ad6d63818b87d89a440cd9757b5',
  nonce: 4848
     }

constructor() {
    this.chain = [this.createGenesisBlock()];
    this.difficulty = 3;
    this.currentTransactions = [];
  }

const SHA256 = require('crypto-js/sha256');

// 區塊類
class Block {
  constructor(index, timestamp) {
    this.index = index;
    this.timestamp = timestamp;
    this.transactions = [];
    this.previousHash = '';
    this.hash = this.calculateHash();
    this.nonce = 0;
  }

  calculateHash() {
    return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.transactions) + this.nonce).toString();    
  }

  mineBlock(difficulty) {
    console.log(`Mining block ${this.index}`);
    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
        this.nonce++;
        this.hash = this.calculateHash();
    }
    console.log("BLOCK MINED: " + this.hash);
}

  getTransactions() {
    return this.transactions;
  }
}

// 區塊鏈類
class Blockchain {
  constructor() {
    this.chain = [this.createGenesisBlock()];
    this.difficulty = 3;
    this.currentTransactions = [];
  }

  addNewTransaction(sender, recipient, amount) {
    this.currentTransactions.push({
      sender,
      recipient,
      amount
    });
  }

  createGenesisBlock() {
    const genesisBlock = new Block(0, "01/10/2017");
    genesisBlock.previousHash = '0';
    genesisBlock.transactions.push({
      sender: 'Leo',
      recipient: 'Janice',
      amount: 520
    });
    return genesisBlock;
  }

  getLatestBlock() {
    return this.chain[this.chain.length - 1];
  }

  addBlock(newBlock) {
    newBlock.previousHash = this.getLatestBlock().hash;
    newBlock.mineBlock(this.difficulty);
    this.chain.push(newBlock);
}

  isChainValid() {
    for (let i = 1; i < this.chain.length; i++){
      const currentBlock = this.chain[i];
      const previousBlock = this.chain[i - 1];

      if(currentBlock.hash !== currentBlock.calculateHash()){
        return false;
      }

      if(currentBlock.previousHash !== previousBlock.hash){
        return false;
      }
    }
    return true;
  }
}

module.exports = {
  Block,
  Blockchain
}

const express = require('express');
const uuidv4 = require('uuid/v4');
const Blockchain = require('./blockchain').Blockchain;

const port = process.env.PORT || 3000;
const app = express();
const nodeIdentifier = uuidv4();
const testCoin = new Blockchain();

// 接口實現
app.get('/mine', (req, res) => {
  res.send("We'll mine a new block.");
});

app.post('/transactions/new', (req, res) => {
  res.send("We'll add a new transaction.");
});

app.get('/chain', (req, res) => {
  const response = {
    chain: testCoin.chain,
    length: testCoin.chain.length
  }
  res.send(response);
})

app.listen(port, () => {
  console.log(`Server is up on port ${port}`);
});

{
  "sender": "my address",
  "recipient": "someone else's address",
  "amount": 5
}

const bodyParser = require("body-parser");
const jsonParser = bodyParser.json();
app.post('/transactions/new', jsonParser, (req, res) => {
  const newTransaction = req.body;
  testCoin.addNewTransaction(newTransaction);
  res.send(`The transaction ${JSON.stringify(newTransaction)} is successfully added to the blockchain.`);
});

app.get('/mine', (req, res) => {
  const latestBlockIndex = testCoin.chain.length;
  const newBlock = new Block(latestBlockIndex, new Date().toString());
  newBlock.transactions = testCoin.currentTransactions;
  // Get a reward for mining the new block
  newBlock.transactions.unshift({
    sender: '0',
    recipient: nodeIdentifier,
    amount: 50
  });
  testCoin.addBlock(newBlock);
  testCoin.currentTransactions = [];
res.send(`Mined new block ${JSON.stringify(newBlock, undefined, 2)}`);
});

app.use((req, res, next) => {
  var now = new Date().toString();
  var log = `${now}: ${req.method} ${req.url}`;
  console.log(log);
  fs.appendFile('server.log', log + '\n', (err) => {
    if (err) console.error(err);
  });
  next();  
})
  res.send(`The transaction 
${JSON.stringify(newTransaction)} is successfully added to the blockchain.`);

import "filename";

import as symbolName from "filename";

import {symbol1 as alias,symbol2}from "filename";

ufixed32x1 f;
ufixed32x1 fi=0.1;//UnimplementedFeatureError:Not yet implemented

： pragma solidity ^0.4.18; 
         contract testType2{
        function interLiteral （）
        public returns (uint,uint){ return(2800+1)-2880,0.5*8);

       }
   }