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);

       }
   }