在iOS上面写一个Blockchain

区块链是什么，到底可以解决什么问题？

简单来说区块链就是一个不需要第三方认证的加密账本交易系统。

举个例子：老王租了老李一个房子，他找中介签房屋合同。
老王拉来了中介小张作为第三方见证人，签署了一个简单合同：
来自 老王 给 老李 房屋出租 时间：某年某月
老王签名 ：老王 老李签名：老李 小张签名： 小张

一式三份，人手一张，基于这份合同：
1，此时老王，老李，都无法否认该合同的存在。因为第三方小张这里有一份存根可以证明。
问题：
2，如果一个合同在老王这里没有存根，那么有一方肯定是伪造的。
3，第三方的信用在这个体系中扮演了重要角色，小张一定要是一个双方都可信的人才行。或者买卖双方老王，老李一起说这个交易没有发生过，小李这个就吃瘪了，中介费拿不到被老板炒鱿鱼。

于是老王和老李，决定找一个新的交易认证方式：
于是区块链的账本交易方式出现了，不需要第三方担保，交易信息不可以篡改，交易内容永远保存。

原理：
公钥加密算法，又称为不对称加密。指的是加密时需要用到一对密钥:公钥和私钥。用私钥加密的内容，可以用公钥很轻松的解开，但是想要加密出同样的内容，不知道私钥几乎是不可行。

过程如下：
双方各自持有一对密钥。
老王和老李互相告知对方自己的公钥。
老王给了老李一张房屋出租的合同。
老李把经过自己的私钥加密的收据发给老王。

现在这个收据就成了合同。用老李的公钥解密之后内容格式合法，就一定是老王签发的。

他们的交易记录链看起来像是这样：

From 老王
加密内容 发送给老李，时间，价值 1
From 老李
加密内容 发送给老王，时间，价值 2

由于老王和老李的公钥是公开的，任何人都可以用这段交易记录算出小王和小红现在的账户余额，不需要第三方证明了。

我们就从这个简单的交易来写一个swift的区块链的智能合约的代码。

一个区块账单（区块）的数据结构是什么样？

区块数据结构.png

简单逻辑：

交易内容 老王 ——>老李 + Private key = 签名信息
交易内容 + public key = 验证信息

交易内容 + nouce（随机数加密）+presh hash
最后一个区块的Hash + 新区块基本信息 + 交易记录信息 + 随机数
每个节点相互链接，记录用Hash = SHA-256

PreHash ——>Hash PreHash ——>Hash
每个账本都有PreHash和Hash，前一个块跟后一个块，hash相连，最后就形成了区块链。

交易内容：from，to，amout
账本（Block）：index（第几个账本），previousHash（前一个hash），hash（后一个hash），nouce（噪音加密）

代码：

    //:打开xcode的Playground，swift
    //: Playground - noun: a place where people can play
   import Cocoa
//数据交易内容
            class Transaction : Codable {
                      var from :String
                        var to :String
                        var amount :Double

      init(from :String, to :String, amount :Double) {
          self.from = from
    self.to = to
    self.amount = amount
}
  }

//账本交易加密
        class Block {
                    var index :Int = 0
                      var previousHash :String = ""
                        var hash :String!
                          var nonce :Int

      private (set) var transactions :[Transaction] = [Transaction]()

var key :String {
    get {
        
        let transactionsData = try! JSONEncoder().encode(self.transactions)
        let transactionsJSONString = String(data: transactionsData, encoding: .utf8)
        
        return String(self.index) + self.previousHash + String(self.nonce) + transactionsJSONString!
    }
}

func addTransaction(transaction :Transaction) {
    self.transactions.append(transaction)
}

init() {
    self.nonce = 0
}
       }

  //账本区块连接成区块链
  class Blockchain { 
   private (set) var blocks :[Block] = [Block]()
   init(genesisBlock :Block) {
          addBlock(genesisBlock)
     }

func addBlock(_ block :Block) {
    
    if self.blocks.isEmpty {
        block.previousHash = "0000000000000000"
        block.hash = generateHash(for :block)
    }
    
    self.blocks.append(block)
}

func getNextBlock(transactions :[Transaction]) -> Block {
    
    let block = Block()
    transactions.forEach { transaction in
        block.addTransaction(transaction: transaction)
    }
    
    let previousBlock = getPreviousBlock()
    block.index = self.blocks.count
    block.previousHash = previousBlock.hash
    block.hash = generateHash(for: block)
    return block

}

private func getPreviousBlock() -> Block {
    return self.blocks[self.blocks.count - 1]
}

func generateHash(for block :Block) -> String {
    
    var hash = block.key.sha1Hash()
    
    while(!hash.hasPrefix("00")) {
        block.nonce += 1
        hash = block.key.sha1Hash()
        print(hash)
    }
    
    return hash
}  
    }

// String Extension
   extension String {
   func sha1Hash() -> String {    
    let task = Process()
    task.launchPath = "/usr/bin/shasum"
    task.arguments = []   
     let inputPipe = Pipe() 
    inputPipe.fileHandleForWriting.write(self.data(using: String.Encoding.utf8)!)     
    inputPipe.fileHandleForWriting.closeFile()
    let outputPipe = Pipe()
    task.standardOutput = outputPipe
    task.standardInput = inputPipe
     task.launch()
    
    let data = outputPipe.fileHandleForReading.readDataToEndOfFile()
    let hash = String(data: data, encoding: String.Encoding.utf8)!
    return hash.replacingOccurrences(of: "  -\n", with: "")
              }
      }

//验证

      let genesisBlock = Block()
      let blockchain = Blockchain(genesisBlock: genesisBlock)
      let transaction = Transaction(from: "Mary", to: "John", amount: 10)
      print("----------------------------------------------")
      let block = blockchain.getNextBlock(transactions: [transaction])
      blockchain.addBlock(block)
      print(blockchain.blocks.count)

将区块链架设部署swift vapor服务器

Target：用Swift写一个区块链交易并架设部署到swift vapor本地服务器
1,将区块链放上服务器,实施区块链Web API