使用Python和Haskell编写的区块链应用

区块链是一种以去中心化和不可篡改的方式存储和验证数据的技术。它通过将数据记录在一个不断增长的链表中，每一个数据块包含了前一个数据块的哈希值，以确保数据的安全性和完整性。在本文中，我们将介绍如何使用Python和Haskell编写一个简单的区块链应用，并提供一些使用示例。

Python代码示例：

import hashlib
import time

class Block:
    def __init__(self, timestamp, data, previous_hash):
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        block_string = "{}{}{}".format(self.timestamp, self.data, self.previous_hash)
        return hashlib.sha256(block_string.encode()).hexdigest()

class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]

    def create_genesis_block(self):
        return Block(time.time(), "Genesis Block", "0")

    def get_latest_block(self):
        return self.chain[-1]

    def add_block(self, new_block):
        new_block.previous_hash = self.get_latest_block().hash
        new_block.hash = new_block.calculate_hash()
        self.chain.append(new_block)

    def is_chain_valid(self):
        for i in range(1, len(self.chain)):
            current_block = self.chain[i]
            previous_block = self.chain[i-1]
            if current_block.hash != current_block.calculate_hash():
                return False
            if current_block.previous_hash != previous_block.hash:
                return False
        return True

# 使用示例
blockchain = Blockchain()
block1 = Block(time.time(), {"amount": 100}, "")
blockchain.add_block(block1)
block2 = Block(time.time(), {"amount": 200}, "")
blockchain.add_block(block2)

print("Block 1 hash: ", block1.hash)
print("Block 2 hash: ", block2.hash)
print("Is blockchain valid? ", blockchain.is_chain_valid())

在这个例子中，我们首先定义了一个Block类，它包含了时间戳、数据、前一个数据块的哈希值和本数据块的哈希值。通过calculate_hash函数，我们根据数据计算数据块的哈希值。

然后，我们定义了一个Blockchain类，其中包含一个链表用于存储所有的数据块。它提供了创建创世块、获取最新块、添加新块、验证链的有效性等函数。

在使用示例中，我们创建了一个空的区块链，并添加了两个数据块。然后，我们打印出每个块的哈希值，并验证整个链的有效性。

接下来我们看看如何使用Haskell编写同样的区块链应用。

Haskell代码示例：

import Data.Time.Clock.POSIX
import Data.Digest.Pure.SHA

type Hash = String

data Block = Block { timestamp :: Int
                   , data' :: String
                   , previousHash :: Hash
                   , hash :: Hash
                   }

calculateHash :: Block -> Hash
calculateHash block = showDigest $ sha256 $ show (timestamp block, data' block, previousHash block)

createBlock :: String -> Hash -> IO Block
createBlock data' previousHash = do
    timestamp <- round fmap getPOSIXTime
    let hash = calculateHash (Block timestamp data' previousHash "")
    return (Block timestamp data' previousHash hash)

data Blockchain = Blockchain { chain :: [Block] }

createGenesisBlock :: IO Block
createGenesisBlock = createBlock "Genesis Block" "0"

getLatestBlock :: Blockchain -> Block
getLatestBlock blockchain = head (chain blockchain)

addBlock :: Blockchain -> Block -> IO Blockchain
addBlock blockchain newBlock = do
    let latestBlock = getLatestBlock blockchain
    let previousHash = hash latestBlock
    newBlock <- createBlock (data' newBlock) previousHash
    let newChain = newBlock : chain blockchain
    return (Blockchain newChain)

isChainValid :: Blockchain -> Bool
isChainValid blockchain = checkChain (chain blockchain)
    where checkChain [] = True
          checkChain [x] = True
          checkChain (currentBlock:previousBlock:xs) =
              if hash currentBlock /= calculateHash currentBlock ||
                 previousHash currentBlock /= hash previousBlock
                 then False
                 else checkChain (previousBlock:xs)

-- 使用示例
main :: IO ()
main = do
    genesisBlock <- createGenesisBlock
    let blockchain = Blockchain [genesisBlock]
    block1 <- createBlock "First Block" (hash genesisBlock)
    blockchain <- addBlock blockchain block1
    block2 <- createBlock "Second Block" (hash block1)
    blockchain <- addBlock blockchain block2
    putStrLn $ "Block 1 hash: " ++ hash block1
    putStrLn $ "Block 2 hash: " ++ hash block2
    putStrLn $ "Is blockchain valid? " ++ show (isChainValid blockchain)

在Haskell代码中，我们首先定义了Block类型，它包含了整型的时间戳、字符串类型的数据、前一个数据块的哈希值和本数据块的哈希值。通过calculateHash函数，我们根据数据计算数据块的哈希值。

然后，我们定义了一个Blockchain类型，其中包含一个链表用于存储所有的数据块。它提供了创建创世块、获取最新块、添加新块、验证链的有效性等函数。请注意，在Haskell中，链表是通过单向链表实现的。

在使用示例中，我们创建了一个创世块，并在此基础上添加了两个数据块。然后，我们打印出每个块的哈希值，并验证整个链的有效性。

这两个示例展示了如何使用Python和Haskell编写一个简单的区块链应用。他们有着类似的实现逻辑，通过链表来存储数据块，通过哈希值来确保数据的安全性和完整性。