精华内容
下载资源
问答
  • python区块链开发

    2018-05-31 23:43:36
    至此,已经完成了:交易记录,区块的开发,现在进行区块链开发就比较容易了。实现代码如下: from Block import InvalidBlock, Block from Message import InvalidMessage, DaDaMessage from Transaction import...

    至此,已经完成了:交易记录,区块的开发,现在进行区块链的开发就比较容易了。实现代码如下:

    from Block import InvalidBlock, Block
    from Message import InvalidMessage, DaDaMessage
    
    from Transaction import Transaction
    
    # 区块链
    class Dada_BlockCoin:
        def __init__(self):
            self.blocklist = []  # 装载所有区块
    
        def validate(self):#校验所有区块
            for i, block in enumerate(self.blocklist):
                try:
                    block.validate()
                except InvalidBlockCoin as e:
                    raise InvalidBlockCoin("区块校验错误,区块索引{}".format(i))
    
        def add_block(self, block):  # 增加区块
            if len(self.blocklist) > 0:
                block.link(self.blocklist[-1])  #连接区块
            block.seal()#密封
            block.validate()#校验
            self.blocklist.append(block)#添加到区块链中
    
    
        def __repr__(self):
            return "Dada_BlockCoin:{}".format(len(self.blocklist))
    

    自定义异常:

    
    class InvalidBlockCoin(Exception):
        def __init__(self, *args, **kwargs):
            super(Exception, self).__init__(*args, **kwargs)
    

    编写测试模块:

    
    if __name__ == "__main__":
        t1 = Transaction("yicheng", "ddd1", 100)
        t2 = Transaction("yicheng", "ddd2", 200)
        t3 = Transaction("yicheng", "ddd3", 300)
        t4 = Transaction("yicheng", "ddd4", 400)
        t5 = Transaction("yicheng", "ddd5", 500)
        t6 = Transaction("yicheng", "ddd6", 600)
    
        m1 = DaDaMessage(t1)
        m2 = DaDaMessage(t2)
        m3 = DaDaMessage(t3)
        m4 = DaDaMessage(t4)
        m5 = DaDaMessage(t5)
        m6 = DaDaMessage(t6)
        try:
    
            yin1 = Block(m1, m2)
            yin1.seal()
            yin2 = Block(m3, m4)
            yin2.seal()
            yin3 = Block(m5, m6)
            yin3.seal()
    
            # 篡改区块
            #yin3.messagelist.append(m1)
    
            coin = Dada_BlockCoin()  # 区块链
            coin.add_block(yin1)
            coin.add_block(yin2)
            coin.add_block(yin3)
    
            coin.validate()
            print(coin)
        except InvalidMessage as e:
            print(e)
        except InvalidBlock as e:
            print(e)
        except InvalidBlockCoin as e:
            print(e)
    

    测试结果如下:
    这里写图片描述
    篡改区块链,测试模块区块链的内容,可以任意篡改,测试结果如下:
    这里写图片描述
    这里已经完成了数据层的部分开发,其余部分后续会完善。
    喜欢区块链技术的小伙伴,欢迎加群加群交流学习:
    区块链技术交流群

    展开全文
  • Python不是主流的区块链...本文介绍了10个最流行的Python区块链项并提供了相应的源代码下载地址。 区块链开发教程链接:以太坊 | 比特币 | EOS | Tendermint | Hyperledger Fabric | Omni/USDT | Ripple 1、web3....

    Python不是主流的区块链底层平台开发语言,但是在DApp开发、区块链仿真与数据分析、智能合约安全分析等领域,Python依然是不错的选择。本文介绍了10个最流行的Python区块链项并提供了相应的源代码下载地址。

    区块链开发教程链接:以太坊 | 比特币 | EOS | Tendermint | Hyperledger Fabric | Omni/USDT | Ripple

    1、web3.py - 以太坊的Python开发接口

    web3.py是访问以太坊区块链及相关生态的Python接口,可以视为web3.js的Python版本的实现,它需要Python 3.6+运行环境。

    在这里插入图片描述

    2、mythril - 以太坊智能合约安全分析工具

    Mythril是以太坊虚拟机字节码的安全分析工具,它支持EVM兼容区块链的智能合约的安全分析,例如以太坊、hedera、quorum、vechain、roostock、tron等。

    在这里插入图片描述

    • Python源码下载:https://github.com/ConsenSys/mythril

    3、Python-blockchain-sim - 适合学习与科研的仿真区块链

    使用Python开发一个多节点的仿真区块链,并基于该仿真区块链网络开发一个去中心化的数据分享应用。 适合进行区块链原理性研究,或者在自己的笔记本上仿真区块链网络并进行研究性实验,例如毕业设计项目或课题研究。本项目代码完整的教程请访问博客Python仿真区块链

    在这里插入图片描述

    • Python源码下载:https://github.com/ezpod/python-blockchain-sim

    4、SimpleCoin - 仿比特币区块链

    一个简单的仿比特币的区块链实现,采用Python开发。项目的目的是创建一种可用的区块链货币,并且尽可能的简单,因此可以用于教学目的。

    在这里插入图片描述

    • Python源码下载:https://github.com/cosme12/SimpleCoin

    5、CrackCoin - 无链数字货币的PoC实现

    Crackcoin是一个无区块链数字加密货币的概念验证实现,采用Python开发。它最大的特点就是没有使用区块链作为加密货币的实现基础,其灵感来自于这篇论文:Blockchain-Free Cryptocurrencies: A Framework for Truly Decentralised Fast Transactions

    在这里插入图片描述

    • Python源码下载:https://github.com/DutchGraa/crackcoin

    6、cert-issuer - 基于区块链的毕业证书签发与验证

    cert-issuer是一个基于比特币或以太坊区块链签发毕业证书的项目,采用Python实现。利用cert-issuer,签发机构通过向区块链提交一个包含证书哈希的交易实现毕业证书的签发,并利用该链上哈希实现毕业证书的验证。

    在这里插入图片描述

    • Python源码下载:https://github.com/blockchain-certificates/cert-issuer

    7、Fabric-sdk-py - 超级账本Fabric区块链的Python开发包

    Fabric-SDK-Py 是Hyperledger Fabric区块链的Python SDK,目前支持Fabric 1.4.x。

    在这里插入图片描述

    • Python源码下载:https://github.com/hyperledger/fabric-sdk-py

    8、octopus

    octopus是一个用于webassembly模块以及区块链智能合约的安全分析工具,其目的是提供一个分析闭源的webassembly模块以及智能合约字节码的简单方法以便更深入的了解这些WASM模块或智能合约的内部行为。

    在这里插入图片描述

    • Python源码下载:https://github.com/pventuzelo/octopus

    9、python-bitcoin-blockchain-parser

    Python-bitcoin-blockchain-parser是一个python 3的比特币区块链原始数据解析器。它可以监测输出类型以及输出中的地址、解析比特币脚本、支持segwit、支持区块排序解析。

    • Python源码下载:https://github.com/alecalve/python-bitcoin-blockchain-parser

    10、Orbit

    Orbit是一个区块链交易调查工具,它通过递归地抓取交易历史来探索区块链网络,然后将数据渲染为图来展示源、目的以及可疑的连接。
    在这里插入图片描述

    • Python源码下载:https://github.com/s0md3v/Orbit

    原文链接:10个最流行的Python区块链项目 — 汇智网

    展开全文
  • Python区块链仿真实现教程及源码

    千次阅读 2020-04-02 09:33:12
    区块链或数字货币领域,Python并不是主流的开发语言。但是如果你的目的是研究区块链技术的原理,或者需要在自己的笔记本上仿真一个区块链网络并进行一些研究性的实验,比如完成自己的毕业设计项目或科研课题,那么...

    在区块链或数字货币领域,Python并不是主流的开发语言。但是如果你的目的是研究区块链技术的原理,或者需要在自己的笔记本上仿真一个区块链网络并进行一些研究性的实验,比如完成自己的毕业设计项目或科研课题,那么Python就是合适的。在这个教程里,我们将学习如何使用Python从零开发一个多节点的区块链网络,并基于这个仿真区块链网络,开发一个去中心化的数据分享应用。

    相关教程链接:区块链毕业论文 | 以太坊 | 比特币 | EOS | Tendermint | Hyperledger Fabric | Omni/USDT | Ripple

    本教程中的完整源代码可以在这里下载:https://github.com/ezpod/python-blockchain-sim。如果你需要仿真大规模区块链网络,可以使用这个区块链仿真开发包

    1、Python仿真区块链:用区块分批保存交易

    我们首先要把数据以JSON格式存入区块链。JSON是一种常用的跨语言的数据交换格式,例如一篇博客的JSON表示看起来就像这样:

    { 
      "author": "some_author_name", 
      "content": "Some thoughts that author wants to share", 
      "timestamp": "The time at which the content was created"
    }
    

    在区块链领域,我们经常使用 交易 来代替上面说到的数据。因此,为了避免引起混乱并保持一致,在这个教程里我们将使用 交易 这个术语来表示要存入区块链的数据。

    交易被分批打包进区块,一个区块可以包含一个或多个交易。包含交易的区块会定期生成并加入区块链。因为会有很多区块,所以每个区块都应当有一个唯一的ID。下面是我们的Python仿真区块链的Block类定义代码:

    class Block:
        def __init__(self, index, transactions, timestamp):
            """
            Constructor for the `Block` class.
            :param index: Unique ID of the block.
            :param transactions: List of transactions.
            :param timestamp: Time of generation of the block.
            """
            self.index = index 
            self.transactions = transactions 
            self.timestamp = timestamp
    

    2、Python仿真区块链:为区块添加抗篡改的数字指纹

    区块链的一个特点就是存储在区块中的交易不可篡改,为了实现这个特性,首先需要能够检测出区块数据被篡改。为此目的,我们需要使用密码学中的哈希(Hash)函数。

    哈希函数可以把任意大小的输入数据转换为固定大小的输出数据,也就是数据的哈希,而且不同的输入数据(基本上)会得到不同的输出数据,因此可以使用输出的哈希作为输入数据的标识。一个理想的哈希函数具有如下特点:

    • 应当易于计算
    • 应当是确定性的,对于相同的输入数据总是生成相同的哈希
    • 应当具有均匀随机性,输入数据的一点变化也会导致输出哈希的显著改变

    这样我们就可以保证:

    • 从哈希猜测出输入数据是什么基本是不可能的,唯一的办法是尝试所有可能的组合
    • 如果同时知道输入和输出,那么你可以通过简单地重算来验证哈希是否正确

    显然,从输入数据推导出哈希很简单,然而从哈希推导出输入数据则是几乎不可能的,这一非对称性值就是区块链用来获取期望的抗篡改能力的关键。

    目前有很多流行的哈希函数,下面是一个使用SHA-256哈希函数的Python示例:

    >>> from hashlib import sha256
    >>> data = b"Some variable length data"
    >>> sha256(data).hexdigest()
    'b919fbbcae38e2bdaebb6c04ed4098e5c70563d2dc51e085f784c058ff208516'
    >>> sha256(data).hexdigest() # no matter how many times you run it, the result is going to be the same 256 character string
    'b919fbbcae38e2bdaebb6c04ed4098e5c70563d2dc51e085f784c058ff208516'
    >>>  data = b"Some variable length data2" # Added one character at the end.
    '9fcaab521baf8e83f07512a7de7a0f567f6eef2688e8b9490694ada0a3ddeec8'
    

    注意在上面的示例中,输入数据的一点变化就得到完全不同的哈希!

    在教程的Python仿真区块链项目中,我们将把区块哈希保存为区块的一个字段,用它作为区块数据的数字指纹(Digital Fingerprint),或者说签名(Signature)。

    下面是计算区块哈希的Python实现代码:

    from hashlib import sha256
    import json
    
    def compute_hash(block):
        """
        Returns the hash of the block instance by first converting it
        into JSON string.
        """
        block_string = json.dumps(self.__dict__, sort_keys=True)
        return sha256(block_string.encode()).hexdigest()
    

    注意:在大多数数字加密货币实现中,区块中的每个交易也需要计算哈希并利用一个树形结构(merkle树)来计算一组交易的根哈希。不过这对于区块链来说并不是必需的,因此我们暂时忽略这一特性。

    3、Python仿真区块链:将区块一个个链接起来

    好了,现在我们已经搞定区块类Block的Python实现了,现在来看看如何用Ptyhon实现区块链结构。

    区块链就是区块的集合,我们可以使用Python列表来保存所有的区块。不过这还不够,因为如果有人故意用一个较早的区块替换掉集合中的新区块还会导致数据被篡改。

    我们需要一个办法来保证对较早的区块的修改会导致整条区块链的无效。比特币使用的办法是让后面区块的哈希依赖于前面较早的区块。为将区块链接起来,我们需要在区块结构中增加一个新的字段来保存前一个区块的哈希:previous_hash。

    好了,如果每个区块都通过previous_hash字段链接到前一个区块,那么第一个区块怎么办?在区块链领域,第一个区块被称为创世区块(Genesis Block),可以手工生成创世区块或者使用一些特定的逻辑。现在让我们为Block类添加previous_hash字段并实现区块链结构定义,下面是Blockchain类的
    Python实现代码:

    from hashlib import sha256
    import json
    import time
    
    
    class Block:
        def__init__(self, index, transactions, timestamp, previous_hash):
            """
            Constructor for the `Block` class.
            :param index:         Unique ID of the block.
            :param transactions:  List of transactions.
            :param timestamp:     Time of generation of the block.
            :param previous_hash: Hash of the previous block in the chain which this block is part of.                                        
            """
            self.index = index
            self.transactions = transactions
            self.timestamp = timestamp
            self.previous_hash = previous_hash # Adding the previous hash field
    
        def compute_hash(self):
            """
            Returns the hash of the block instance by first converting it
            into JSON string.
            """
            block_string = json.dumps(self.__dict__, sort_keys=True) # The string equivalent also considers the previous_hash field now
            return sha256(block_string.encode()).hexdigest()
    
    class Blockchain:
    
        def __init__(self):
            """
            Constructor for the `Blockchain` class.
            """
            self.chain = []
            self.create_genesis_block()
    
        def create_genesis_block(self):
            """
            A function to generate genesis block and appends it to
            the chain. The block has index 0, previous_hash as 0, and
            a valid hash.
            """
            genesis_block = Block(0, [], time.time(), "0")
            genesis_block.hash = genesis_block.compute_hash()
            self.chain.append(genesis_block)
    
        @property
        def last_block(self):
            """
            A quick pythonic way to retrieve the most recent block in the chain. Note that
            the chain will always consist of at least one block (i.e., genesis block)
            """
            return self.chain[-1]
    

    现在,如果任何较早的区块被修改,那么:

    • 该较早区块的哈希会变化
    • 这会导致与后面区块的previous_hash字段记录的内容不一致
    • 由于计算区块哈希的输入数据包含了previous_hash字段的内容,因此下一个区块的哈希也会变化

    最终,从被替换掉的区块开始的整条链都失效了,修复这一问题的唯一办法是重算整条链。

    4、Python仿真区块链:实现工作量证明算法

    不过还有一个问题。如果我们修改了之前的区块,如果重算后面的其他区块非常简单的话,那么篡改区块链也不是什么难事了。为了避免这一问题,我们可以利用前面提到的哈希函数的非对称性来加大区块哈希计算工作的难度和随机性。我们要做的是:只接受符合特定约束条件的区块哈希。现在让我们增加一个约束条件,要求区块哈希的开始部分至少有n个0,其中n是一个正整数。

    我们知道,除非改变区块数据的内容,否则区块哈希不会变化,当然我们也不希望修改已有的数据。那么我们该怎么做?很简单!我们再增加一些我们可以随便修改的数据就是了。因此我们需要为Block类增加一个新的字段nonce,我们可以通过改变这个字段的值来得到不同的区块哈希,直到满足指定的约束条件,而这时的nonce值就是我们工作量的证明。

    上面的这一过程就是比特币使用的hashcash算法的简化版本。约束条件中指定的前导0的数量决定了我们的工作量证明算法的难度:前导0的数量越多,就越难找到合适的nonce。

    同时,由于哈希函数的非对称性,工作量证明不容易计算,但是容易进行验证。

    下面是工作量证明算法(PoW:Proof of Work)的Python实现代码:

    class Blockchain:
        # difficulty of PoW algorithm
        difficulty = 2
    
        """
        Previous code contd..
        """
    
        def proof_of_work(self, block):
            """
            Function that tries different values of the nonce to get a hash
            that satisfies our difficulty criteria.
            """
            block.nonce = 0
    
            computed_hash = block.compute_hash()
            while not computed_hash.startswith('0' * Blockchain.difficulty):
                block.nonce += 1
                computed_hash = block.compute_hash()
    
            return computed_hash
    

    需要指出的是,没有简单的逻辑可以快速找到满足约束条件的nonce值,因此只能进行暴力计算。

    5、Python仿真区块链:将区块加入区块链

    要将区块加入区块链,我们首先需要验证:

    • 区块中的数据没有被篡改,所提供的工作量证明是正确的
    • 交易的顺序是正确的,previous_hash字段指向我们链上最新区块的哈希

    现在让我们看一下将区块上链的Python实现代码:

    class Blockchain:
        """
        Previous code contd..
        """
    
        def add_block(self, block, proof):
            """
            A function that adds the block to the chain after verification.
            Verification includes:
            * Checking if the proof is valid.
            * The previous_hash referred in the block and the hash of a latest block
              in the chain match.
            """
            previous_hash = self.last_block.hash
    
            if previous_hash != block.previous_hash:
                return False
    
            if not Blockchain.is_valid_proof(block, proof):
                return False
    
            block.hash = proof
            self.chain.append(block)
            return True
    
        def is_valid_proof(self, block, block_hash):
            """
            Check if block_hash is valid hash of block and satisfies
            the difficulty criteria.
            """
            return (block_hash.startswith('0' * Blockchain.difficulty) and
                    block_hash == block.compute_hash())
    

    6、Python仿真区块链:挖矿

    交易一开始是保存在未确认交易池中的。将未确认交易放入区块并计算工作量证明的过程,就是广为人知的挖矿。一旦找出了满足指定约束条件的nonce,我们就可以说挖出了一个可以上链的区块。

    在大多数数字加密货币中,包括比特币,矿工都会得到加密货币奖励,以回报其为计算工作量证明所投入的算力。下面是我们的挖矿函数的Python实现代码:

    class Blockchain:
    
        def __init__(self):
            self.unconfirmed_transactions = [] # data yet to get into blockchain
            self.chain = []
            self.create_genesis_block()
    
        """
        Previous code contd...
        """
    
        def add_new_transaction(self, transaction):
            self.unconfirmed_transactions.append(transaction)
    
        def mine(self):
            """
            This function serves as an interface to add the pending
            transactions to the blockchain by adding them to the block
            and figuring out proof of work.
            """
            if not self.unconfirmed_transactions:
                return False
    
            last_block = self.last_block
    
            new_block = Block(index=last_block.index + 1,
                              transactions=self.unconfirmed_transactions,
                              timestamp=time.time(),
                              previous_hash=last_block.hash)
    
            proof = self.proof_of_work(new_block)
            self.add_block(new_block, proof)
            self.unconfirmed_transactions = []
            return new_block.index
    

    好了,我们就快要完成这个Python仿真区块链项目了!

    7、Python仿真区块链:为节点添加API接口

    现在该为我们的仿真区块链节点添加API接口了,这样应用程序就可以利用这些API开发具体的应用。我们将使用流行的Python微框架Flask来创建REST API。如果你以前使用过其他web框架,那么下面的代码应当不难理解,如果没有接触过web框架的话也别担心,这里有一个非常棒的Flask教程

    from flask import Flask, request
    import requests
    
    # Initialize flask application
    app =  Flask(__name__)
    
    # Initialize a blockchain object.
    blockchain = Blockchain()
    

    我们需要一个可以提交新交易的访问端节点,这样我们的应用就可以利用这个API来将新数据添加到区块链中。下面是节点的/new_transaction访问端节点的Python实现代码:

    # Flask's way of declaring end-points
    @app.route('/new_transaction', methods=['POST'])
    def new_transaction():
        tx_data = request.get_json()
        required_fields = ["author", "content"]
    
        for field in required_fields:
            if not tx_data.get(field):
                return "Invalid transaction data", 404
    
        tx_data["timestamp"] = time.time()
    
        blockchain.add_new_transaction(tx_data)
    
        return "Success", 201
    

    另一个端节点/chain可以返回区块链的数据。我们的应用将利用这个API来查询要显示的数据。下面是这个端节点的Python实现代码:

    @app.route('/chain', methods=['GET'])
    def get_chain():
        chain_data = []
        for block in blockchain.chain:
            chain_data.append(block.__dict__)
        return json.dumps({"length": len(chain_data),
                           "chain": chain_data})
    

    挖矿很费CPU,因此我们不希望让节点一直挖矿,而是提供一个访问端节点/mine来提供按需挖矿服务。 下面是Python实现代码:

    @app.route('/mine', methods=['GET'])
    def mine_unconfirmed_transactions():
        result = blockchain.mine()
        if not result:
            return "No transactions to mine"
        return "Block #{} is mined.".format(result)
    
    @app.route('/pending_tx')
    def get_pending_tx():
        return json.dumps(blockchain.unconfirmed_transactions)
    

    这些REST访问端节点可以用来操作我们的区块链,比如提交一些交易,然后通过挖矿确认这些交易等等。

    8、Python仿真区块链:实现最长链共识与去中心化计算

    到目前为止,我们用Python从零实现的仿真区块链是运行在一台计算机上的。即使我们已经利用哈希将区块前后链接起来,并应用了工作量证明约束,我们还是不能只信任单一的节点。我们需要实现分布式数据存储,我们需要多个节点来维护区块链。因此,为了从单一节点转向P2P网络,让我们先
    创建一个机制来让网络上的节点彼此了解。

    首先定义一个新的访问端节点/register_node用来在网络中注册新节点。下面是Python实现代码:

    # Contains the host addresses of other participating members of the network
    peers = set()
    
    # Endpoint to add new peers to the network
    @app.route('/register_node', methods=['POST'])
    def register_new_peers():
        # The host address to the peer node 
        node_address = request.get_json()["node_address"]
        if not node_address:
            return "Invalid data", 400
    
        # Add the node to the peer list
        peers.add(node_address)
    
        # Return the blockchain to the newly registered node so that it can sync
        return get_chain()
    
    @app.route('/register_with', methods=['POST'])
    def register_with_existing_node():
        """
        Internally calls the `register_node` endpoint to
        register current node with the remote node specified in the
        request, and sync the blockchain as well with the remote node.
        """
        node_address = request.get_json()["node_address"]
        if not node_address:
            return "Invalid data", 400
    
        data = {"node_address": request.host_url}
        headers = {'Content-Type': "application/json"}
    
        # Make a request to register with remote node and obtain information
        response = requests.post(node_address + "/register_node",
                                 data=json.dumps(data), headers=headers)
    
        if response.status_code == 200:
            global blockchain
            global peers
            # update chain and the peers
            chain_dump = response.json()['chain']
            blockchain = create_chain_from_dump(chain_dump)
            peers.update(response.json()['peers'])
            return "Registration successful", 200
        else:
            # if something goes wrong, pass it on to the API response
            return response.content, response.status_code
    
    
    def create_chain_from_dump(chain_dump):
        blockchain = Blockchain()
        for idx, block_data in enumerate(chain_dump):
            block = Block(block_data["index"],
                          block_data["transactions"],
                          block_data["timestamp"],
                          block_data["previous_hash"])
            proof = block_data['hash']
            if idx > 0:
                added = blockchain.add_block(block, proof)
                if not added:
                    raise Exception("The chain dump is tampered!!")
            else:  # the block is a genesis block, no verification needed
                blockchain.chain.append(block)
        return blockchain
    

    新加入网络的节点可以利用/register_with endpoint端节点调用register_with_existing_node方法进行注册。这有助于解决以下问题:

    • 要求远端节点在其已知邻节点中添加一个新的条目
    • 使用远端节点的数据初始化新节点上的区块链
    • 如果节点中途有下线,而可以重新从网络同步区块链

    然而,当存在多个区块链节点时有一个问题需要解决:不管有意或无意(例如网络延迟),不同节点上的区块链可能彼此不同。在这种情况下,节点之间需要就区块链的版本达成一致,以便维护整个系统的一致性。换句话说,我们需要达成共识。

    当不同节点上的区块链出现分化时,一个简单的共识算法是选择最长有效链。这一方法背后的合理性在于,最长的链包含了最多的已经投入的工作量证明计算。下面是最长链共识算法的Python实现代码:

    class Blockchain
        """
        previous code continued...
        """
        def check_chain_validity(cls, chain):
            """
            A helper method to check if the entire blockchain is valid.            
            """
            result = True
            previous_hash = "0"
    
            # Iterate through every block
            for block in chain:
                block_hash = block.hash
                # remove the hash field to recompute the hash again
                # using `compute_hash` method.
                delattr(block, "hash")
    
                if not cls.is_valid_proof(block, block.hash) or \
                        previous_hash != block.previous_hash:
                    result = False
                    break
    
                block.hash, previous_hash = block_hash, block_hash
    
            return result
    
    def consensus():
        """
        Our simple consensus algorithm. If a longer valid chain is
        found, our chain is replaced with it.
        """
        global blockchain
    
        longest_chain = None
        current_len = len(blockchain.chain)
    
        for node in peers:
            response = requests.get('{}/chain'.format(node))
            length = response.json()['length']
            chain = response.json()['chain']
            if length > current_len and blockchain.check_chain_validity(chain):
                  # Longer valid chain found!
                current_len = length
                longest_chain = chain
    
        if longest_chain:
            blockchain = longest_chain
            return True
    
        return False
    

    现在,我们需要提供一个Python方法让节点在挖出区块时可以将这一消息广播给其他节点,这样我们的仿真区块链网络中的每个参与者都可以更新其本地区块链,然后接着挖下一个区块。收到区块广播的节点很简单就可以验证工作量证明,然后将收到区块加入到自己的本地链上。

    下面是节点的/add_block访问端节点的Python实现代码:

    # endpoint to add a block mined by someone else to
    # the node's chain. The node first verifies the block
    # and then adds it to the chain.
    @app.route('/add_block', methods=['POST'])
    def verify_and_add_block():
        block_data = request.get_json()
        block = Block(block_data["index"],
                      block_data["transactions"],
                      block_data["timestamp"],
                      block_data["previous_hash"])
    
        proof = block_data['hash']
        added = blockchain.add_block(block, proof)
    
        if not added:
            return "The block was discarded by the node", 400
    
        return "Block added to the chain", 201
    
    
    def announce_new_block(block):
        """
        A function to announce to the network once a block has been mined.
        Other blocks can simply verify the proof of work and add it to their
        respective chains.
        """
        for peer in peers:
            url = "{}add_block".format(peer)
            requests.post(url, data=json.dumps(block.__dict__, sort_keys=True))
    

    announce_new_block方法应当在区块被挖出的时候调用,这样其他节点就可以更新自己本地保存的区块链副本:

    @app.route('/mine', methods=['GET'])
    def mine_unconfirmed_transactions():
        result = blockchain.mine()
        if not result:
            return "No transactions to mine"
        else:
            # Making sure we have the longest chain before announcing to the network
            chain_length = len(blockchain.chain)
            consensus()
            if chain_length == len(blockchain.chain):
                # announce the recently mined block to the network
                announce_new_block(blockchain.last_block)
            return "Block #{} is mined.".format(blockchain.last_block.index
    

    9、Python仿真区块链:开发去中心化应用程序

    好了,现在我们的仿真区块链的节点软件已经开发完了。现在需要开发应用程序的用户界面了。我们使用Jinja2模板来渲染网页,并使用一些CSS来让网页看起来美观一些。

    我们的应用需要连接到这个仿真区块链网络中的某个节点以便获取数据或者提交新数据。下面是应用的初始化部分的Python代码:

    import datetime
    import json
    
    import requests
    from flask import render_template, redirect, request
    
    from app import app
    
    # Node in the blockchain network that our application will communicate with
    # to fetch and add data.
    CONNECTED_NODE_ADDRESS = "http://127.0.0.1:8000"
    
    posts = []
    

    fetch_posts方法利用节点的/chain端节点获取数据、解析数据并保存在本地:

    def fetch_posts():
        """
        Function to fetch the chain from a blockchain node, parse the
        data, and store it locally.
        """
        get_chain_address = "{}/chain".format(CONNECTED_NODE_ADDRESS)
        response = requests.get(get_chain_address)
        if response.status_code == 200:
            content = []
            chain = json.loads(response.content)
            for block in chain["chain"]:
                for tx in block["transactions"]:
                    tx["index"] = block["index"]
                    tx["hash"] = block["previous_hash"]
                    content.append(tx)
    
            global posts
            posts = sorted(content,
                           key=lambda k: k['timestamp'],
                           reverse=True)
    

    应用程序使用一个HTML表单来接收用户输入然后利用一个POST请求将交易添加到所连接节点的未确认交易池中。然后交易会被我们的仿真区块链网络确认并最终当刷新网页时被再次读取:

    @app.route('/submit', methods=['POST'])
    def submit_textarea():
        """
        Endpoint to create a new transaction via our application
        """
        post_content = request.form["content"]
        author = request.form["author"]
    
        post_object = {
            'author': author,
            'content': post_content,
        }
    
        # Submit a transaction
        new_tx_address = "{}/new_transaction".format(CONNECTED_NODE_ADDRESS)
    

    10、Python仿真区块链:如何运行应用

    终于完成了!你可以在github上查看这个Python仿真区块链的完整源代码。

    首先克隆项目仓库:

    $ git clone https://github.com/ezpod/python-blockchain-sim.git
    

    安装必要的Python项目依赖:

    $ cd python_blockchain_app
    $ pip install -r requirements.txt
    

    启动我们的仿真区块链节点:

    $ export FLASK_APP=node_server.py
    $ flask run --port 8000
    

    现在我们的一个仿真区块链节点实例已经启动并在8000端口监听。

    开启另一个终端运行我们的去中心化应用:

    $ python run_app.py
    

    现在应用已经启动,可以通过这个网址访问: http://localhost:5000.

    下图展示了如何利用web界面向我们的仿真区块链提交内容:

    在这里插入图片描述

    下图展示了如何利用web界面启动节点挖矿:

    在这里插入图片描述

    下图展示了如何利用web界面重新同步区块链数据:

    在这里插入图片描述

    11、Python仿真区块链:运行多个节点

    要运行包含多个节点的仿真区块链网络,可以使用register_with/端节点在网络中注册新节点。

    下面是一个多节点的示例场景,我们启动了3个仿真节点,分别在8000、8001和8002端口监听:

    # already running
    $ flask run --port 8000 &
    # spinning up new nodes
    $ flask run --port 8001 &
    $ flask run --port 8002 &
    

    可以使用下面的cURL请求注册在8001和8002端口监听的两个新节点:

    $ curl -X POST \
      http://127.0.0.1:8001/register_with \
      -H 'Content-Type: application/json' \
      -d '{"node_address": "http://127.0.0.1:8000"}'
    
    $ curl -X POST \
      http://127.0.0.1:8002/register_with \
      -H 'Content-Type: application/json' \
      -d '{"node_address": "http://127.0.0.1:8000"}'
    

    这样在端口8000监听的节点就可以知道还有8001和8002监听的节点,反之亦然。新加入的节点也会从原来的在网节点同步区块链数据,这样新节点就可以参与后续的挖矿过程了。

    要修改前端应用同步的区块链节点,可以修改views.py文件中的CONNECTED_NODE_ADDRESS字段。

    一旦完成上面的操作,你就可以运行应用(python run_app.py)并通过web界面创建交易了。当你挖矿后,网络中的所有节点都会更新自己的本地区块链。也可以使用cURL或Postman利用/chain端节点查看区块链。例如:

    $ curl -X GET http://localhost:8001/chain
    $ curl -X GET http://localhost:8002/chain
    

    12、Python仿真区块链:如何验证交易

    你可能注意到我们的基于仿真区块链的去中心化应用还有一点瑕疵:任何人在任何时间都可以提交任何内容。解决这一问题的一个办法,就是使用非对称密钥技术创建用户账户。每一个新用户都需要一个公钥(对应账户名)和一个私钥才能在我们的应用中提交数据。私钥用来创建数据的签名,而公钥用来验证数据的签名,下面是其工作机制:

    • 每一个提交的新交易都使用用户的私钥进行签名。这个签名与用户信息一起 添加到交易数据中
    • 在验证阶段,当挖矿时,我们可以使用公钥和签名验证数据中生成的发送方 和签名是否相符,以及验证消息是否被修改。

    13、Python仿真区块链:教程总结

    在这个教程中,我们学习了一个公链的基本概念,并利用Python实现了一个仿真区块链以及基于这个仿真区块链的Flask应用。如果你走完了整个教程,相信应该可以使用Python从零实现一个区块链,并基于这个仿真的区块链开发自己的去中心化应用,或者利用这个仿真区块链网络进行一些研究性的实验。教程中的区块链实现没有比特币或以太坊那么复杂,但相信会有助于理解区块链技术的核心问题和解决思路。


    原文链接:Python仿真区块链 — 汇智网

    展开全文
  • 主要介绍了python区块及区块链开发详解的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 通过BuildingOne学习区块链这是我的文章《构建区块链》的源代码。 安装确保已安装Python 3.6+。 安装pipenv。 $ pip install pipenv安装要求通过构建一个模块学习区块链这是我的文章“构建一个区块链”的源代码。 ...
  • 《使用BSN 一天学会区块链开发》系列文章可以帮助具有一定开发经验的开发者,在不需要学习区块链开发语言的情况下,在区块链服务网络(BSN)上完成区块链应用的开发。 本文主要介绍用户如何通过链下业务系统使用Python...

    《使用BSN 一天学会区块链开发》系列文章可以帮助具有一定开发经验的开发者,在不需要学习区块链开发语言的情况下,在区块链服务网络(BSN)上完成区块链应用的开发。

    本文主要介绍用户如何通过链下业务系统使用Python语言与链上数据进行交互而进行的相关操作流程说明,但在说明链下业务系统与链上进行数据交互之前,首先对用户如何在区块链服务门户注册、应用发布服务、应用服务参与以及应用管理进行一一说明。

    注册和登录

    打开区块链服务网络网址:www.bsnbase.com, 点击登录页面中的【内测申请】按钮进入内测申请页:

    在这里插入图片描述

    根据页面中的提示填写内测申请信息并提交内测申请,内测申请用户分为个人用户和企业用户两种,申请人应根据自己的用户类型任选一种进行申请, 内测申请提交后需等待系统审核,待系统审核通过后将向申请者发送激活邮件,申请用户可根据【激活邮件】中的激活链接来激活账, 帐户激活后即可登录系统使用。

    应用服务发布

    应用服务是指在区块链服务网络中已经发布并运行的区块链应用,用户可以通过服务网络门户发布自己的区块链应用服务,应用服务分为公开和非公开两种(内测期间发布的服务默认为非公开,如需公开服务需提交公开申请,后台运营人员进行审核,只有审核通过后服务才可在服务门户的应用商店中进行查看),此处就不一一截图了,就概述一下应用服务发布整体流程:

    ■登录区块链服务门户以后,进入我发布的应用->我发布的服务页面;

    ■ 点击创建新服务按钮,进入创建新服务页面,根据提示输入相应的信息;

    ■ 点击下一步按钮开始上传链码包(上传链码包可以使用自己开发的链码包或直接使用服务网络提供的预制链码包),再定义服务功能及角色(表示链下业务系统调用链码所对应的权限)、选择发布的城市节点(表示当前发布的服务所对应的链码部署在哪些城市节点)、付费周期以及是否使用云服务等信息;

    ■ 继续点击下一步按钮,进入到设置接入方式页面,输入网站地址、移动终端接入以及API服务接入等信息(接入方式均为链下接入的相关信息),如果暂时不需要设置接入方式,可跳过此页面继续点击下一步按钮,进入服务账单页面进行确定(服务网络内测其间,所有资源均免费使用);

    ■ 点击确定后,在我发布的应用->我发布的服务列表页面可以看到该条新创建的服务,且该服务的状态为“待初审”状态,发布者需等待运营和运维人员进行审核和发布,服务发布后发布者默认不参与服务。

    应用服务参与

    在服务网络内测期间,所有发布的服务均为非公开,如果自己或其他用户想要参与已经发布的服务,可通过在我发布的应用->我发布的服务列表中邀请参与者,将邀请参与者的链接地址发给需要参与服务的用户,应用参与服务整体流程如下:

    ■ 根据邀请的链接地址,进入服务信息页面,点击申请参与应用按钮,进入服务角色及城市节点选择页面;

    ■ 选择需要使用的服务角色和城市节点(角色是指用户参与服务后链下业务系统访问链上所对应的权限;城市节点是指用户的链下业务系统通过该城市节点与链上进行数据交互)。用户选择服务角色以后,系统会显示角色对应的功能使用费,选择城市节点的时候申请新证书或选择已有的证书。

    ■ 点击确定按钮,提示接入城市节点、接入方式以及费用信息:

    ■ 确认参与服务的接入城市节点、接入方式以及费用信息(内测期间,所有资源均免费)后,在我参与的应用->我参与的列表页面可以查看到所参与的应用服务,该应用服务的状态为待发布者审核,等待应用服务的发布者对参与者进行审核。

    ■ 服务网络内测期间只要发布者对服务参与申请审核通过后,服务参与信息的状态更新为已确认。至此,参与应用服务成功。

    ■ 应用服务参与成功以后,链下业务系统就可以调用城市节点所对应的节点网关,将数据推送上链和从获取上链数据以及链上区块信息,调用节点网关所对应的参数可进入我参与的服务->我参与的->查看->接入的城市节点和服务接入配置参数部分进行查看,接入的城市节点用于接入的城市节点证书进行下载以及城市节点网关的调用地址进行展示,应用服务接入配置参数用于对链下业务系统调用城市节点网关的相关参数进行展示,此部分的细节描述参考“数据交互”部分;

    应用管理

    应用服务发布以后,可进入我发布的应用->我发布的服务管理列表中对已经发布的服务进行统一管理,管理列表具体包含以下功能:

    ■ 邀请参与者:主要用于将应用参与的邀请链接地址发给其它用户,其它用于可以通过此邀请链接地址参与此服务;

    ■ 申请公开:主要是内测期间,所有发布的服务默认均为非公开,如果需要将服务公开,则可以通过此功能提交公开申请;

    ■ 服务升级:主要用于对应用服务的链码包进行升级;

    ■ 配置升级:主要用于对应用服务的配置资源进行升级,如部署的城市节点以及节点的资源的配置信息;

    ■ 历史版本:主要用于对服务升级以后的历史版本进行查询;

    ■ 运行信息:主要用于对应用服务的部署节点以及节点资源信息和链上数据(来源于链下业务系统通过调用节点网关接口将数据推送上链)进行监控;

    ■ 设置接入方式:主要用于对应用服务的链下业务系统的接入进行配置;

    ■ 查看:主要用于对应用服务的基本信息、链码及部署信息、服务角色信息、审批记录信息以及接入方式等信息进行查看。

    应用链码开发

    链码(ChainCode)又称为智能合约,是用计算机语言描述合约条款、交易的条件、交易的业务逻辑等,通过调用智能合约实现交易的自动执行和对账本数据的操作。一个区块链应用可以部署多个链码,每个链码包含多个方法。

    链码支持多种语言编写,包括golang、java、node.js。每个链码程序都必须实现Chaincode接口,链码包含:Init ,Invoke,Query三个基本操作:

    ■ Init :链码初始化的方法,在链码实例化或者升级的时候调用一次,以便链码可以执行任何必要的 初始化,包括应用程序状态的初始化。

    ■ Invoke:接收和处理链下业务系统调用事务处理提案,其参数包含调用的链码程序中函数的名称和具体业务处理数据参数。即在Invoke中根据不同的方法参数调用其他分支处理响应的业务。Invoke可以简单的理解为链码方法的入口。

    ■ Query:提供查询链码数据的方法,该方法只作为查询使用,不提供操作链上数据的操作。可在Query操作时调用,亦可在Invoke方法中作为某些方法的分支被调用。该方法可以不实现。

    下面以通用数据链码包为例详细说明一下。

    通用数据链码包是我们为应用开发者提供对业务数据进行增删改查基本操作的链码(Golang语言编写)。应用开发者可以在此链码包的基础上根据应用业务需求进一步拓展链码功能。此链码支持存储的数据类型有字符串、整型、浮点型、集合(map、list)等等。

    链码包下载地址: www.bsnbase.com/static/base/BaseChainCode.zip

    1.链码包功能如下:

    1.1.增加数据(set)

    输入参数说明

    baseKey:需要保存的唯一的主键标识,baseValue:保存的数据信息

    例:{“baseKey”:“str”,“baseValue”:“this is string”}

    注:其中baseKey是不能为空的字符串,baseValue可以是任意类型的数据。如果baseKey已经存在,则直接返回已经存在,不能添加;如果不存在,则添加数据。

    1.2. 修改数据(update)

    输入参数说明

    baseKey:需要修改的唯一的主键标,baseValue:保存的数据信息

    例:{“baseKey”:“str”,“baseValue”:“this is string”}

    注:其中baseKey是不能为空的字符串,baseValue可以是任意类型的数据。如果baseKey不存在,则无法更新,如果已经存在,则修改数据。

    1.3. 删除数据(delete)

    输入参数说明

    baseKey:需要删除的唯一的主键标识的值

    例:“str”

    注:其中baseKey的值不能为空,且必须存在,否则将无法删除。

    1.4. 获取数据(get)

    输入参数说明

    baseKey:需要获取的唯一的主键标识的值

    例:“str”

    注:其中baseKey的值不能为空,且必须存在,否则将无法获取到相应的信息。

    2.链码介绍

    2.1.Init方法

    在这里插入图片描述

    这个就是最简单的链码初始化功能,写日志、初始化一条数据、保存到数据库、响应。

    建议在链码初始化(Init)的时候,不要有太多的业务操作。

    2.2. Invoke
    在这里插入图片描述

    stub.GetFunctionAndParameters():获取请求的方法名称(string)和参数信息([]string)

    return t.set(stub, args)//调用保存的方法,具体的业务处理

    节点网关

    节点网关是部署在各个城市节点,接收应用系统的请求,使用托管的用户身份信息,向相应的应用链码发起访问并返回链码的执行结果。节点网关的调用是通过向区块链服务的各个城市节点的网关服务发送HTTP请求来实现。节点网关负责验证用户身份信息、应用信息,通过用户身份信息和应用信息以及需要访问的链码、链码方法来传递链码参数、获取链码执行结果的服务通道。

    业务系统需要按照接口说明在请求中加入相应的请求参数,调用节点网关以后,节点网关会返回链码的执行结果。

    接口地址:https://节点网关地址/api/node/reqChainCode

    注:用户参与服务成功后可以在服务详情页面查看并下载应用链下业务系统开发所需要的应用服务配置参数、节点网关地址和应用身份证书,如下图:
    在这里插入图片描述

    通讯方式:POST

    签名算法:

    1、将userCode+ appCode+ chainCode+ funcName的值以及args中每一项数据拼接成字符串A;

    2、对字符串A使用用户证书的私钥进行SHA256WITHECDSA签名。

    请求参数
    在这里插入图片描述
      响应参数
    在这里插入图片描述

    数据交互

    应用服务参与审核通过之后,链下业务系统就可以通过节点网关与链上数据进行数据交互,调用节点网关需要节点网关接入地址、节点网关请求参数以及证书等信息,此部分数据可以通过我参与的应用->我参与的->查看明细页面进行获取,下面对这三方面的参数进行一一说明;

    ● 节点网关接入地址:为链下业务系统调用链上所对应的城市节点入口,所有与链上的数据交互都是通过此地址进行访问,如下图所示:

    在这里插入图片描述

    ● 节点网关请求参数:如果需要通过节点网关接入地址与链上进行数据交互,肯定需要按照节点网关接口调用规范,节点网关接口调用需要userCode、appCode、tid、chainCode、funcName、agrs等参数信息,下面对相关参数进行概要说明。

    ▶ userCode:应用发布者或者参与者的登录名(也就是登录门户的用户名)。

    ▶ appCode:参与应用的唯一标识。应用创建时,系统自动生成的唯一标识。

    ▶tid:用户与参与的应用之间关联的唯一标识。

    ▶ chainCode:区块链服务网络中,运维部署的链码的名称。需要注意的是,这里的链码名称不是服务发布时的链码名称。

    ▶ funcName:调用链码的方法名称。

    ▶ agrs:调用链码方法的参数集合。字符串类型的数组,参与者需要与应用发布者联系,获取方法对应的参数。

    参数获取页面如下图所示:

    在这里插入图片描述

    ■ 节点用户证书:在请求节点网关过程中需要https证书、请求报文签名证书(即用户身份证书)和响应结果验签证书。

    ▶ https请求证书:为保障数据传输层的安全,需要使用https请求。

    ▶ 请求报文签名证书:用户私钥证书。

    ▶ 响应结果验签证书:网关公钥证书。

    用户身份证书的下载可以通过我参与的应用->我参与的->查看->接入的城市节点部分进行下载,也可以通过进入我的身份证书-证书查看列表中找到对应的应用信息,进行证书下载。下载的证书文件包含https证书、用户证书(私钥证书、公钥证书(网关对报文的验签))、网关证书(网关公钥证书)。证书下载页面如下图所示
    在这里插入图片描述
    在这里插入图片描述

    业务系统开发

    业务系统就是链下业务系统,需要与链上进行数据交互的系统,下面根据预置链码包的Python开发实例(可从门户下载)着重说一下与网关交互的说明。

    项目环境准备:
      1、Pycharm/VS Code(可以使用您习惯的IDE)
      2、Python 3.6.6+
      3、Django 2.2.5
      4、Django-bootstrap3 11.1.0
      5、requests 2.22.0
      6、cryptography 2.7
      7、fabric-sdk-py 0.8.1
      注:可根据requirements.txt文件自动安装依赖
      项目介绍:

    在这里插入图片描述

    上图为项目的目录结构:

    该项目使用Python-Django框架,直接调用服务网关api接口,实现数据交互:

    1、 common 文件夹下文件说明:

    l myecdsa256.py(椭圆曲线 SHA256WITHECDSA 签名方法和验签方法)

    l loggers.py(日志方法)

    2、 certificate 文件夹下文件说明(下载用户证书zip包获取):

    l bsn_https.pem(https请求的公钥证书)

    l gateway_public_cert.pem(网关公钥证书)

    l private_key.pem(用户私钥证书)

    l public_cert.pem(用户公钥证书)

    3、 packages 文件夹下文件说明 :

    l fabric-sdk-py-master.zip (fabric官方py库包,需解压后手动安装到python第三方库中 )

    4、logs 文件夹下存放日志文件。

    流程说明:

    1、 用户在客户端(web页面)填写上链信息

    2、 进入相应的方法,获取用户填写的上链信息,并且判断输入信息不可为空

    3、 拼接待签名的字符串,对字符串使用用户私钥证书进行 SHA256WITHECDSA 签名加密(调用myecdsa256下的ecdsa_sign方法生成base64格式的mac值)

    4、 发起post请求,并且附加HTTPS证书

    5、 获取返回报文中的mac值,对返回报文中的mac值,使用网关的公钥证书进行验签,验签内容与传参时签名字符串相同

    6、 若验签成功,则将链上返回报文处理后,显示到web页面中

    详细说明
    在这里插入图片描述
    在这里插入图片描述
      发起请求(以添加数据save为例)
      在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 项目功能 学生培养计划可视化,学生能够直观地了解个人的培养计划进度情况和学分信息,从而更加有针对性地选择课程。 使用SVD算法,可根据其他用户的课程... 执行 python main.py 打开浏览器,输入 localhost:5000 部署
  • 区块链API库(Python,v1) 与Blockchain.info API进行交互的官方Python模块。 与Python 2和Python 3兼容。 入门 通过pip安装: $ pip install blockchain 手动安装: $ git clone ...
  • Python编写区块链

    2018-07-27 22:41:15
    本项目是之前听普林斯顿区块链项目公开课时做的区块链项目练习,使用python语言编写。但是我对于python的flask的框架和网络编程有些不熟悉,加上由于考研时间比较紧张,因此一直没能完善网络编程部分,在这里希望有...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 如今,比特币仍是数字货币的绝对主流,数字货币呈现了百花齐放的状态,常见的有bitcoin、litecoin、dogecoin、dashcoin,除了货币的应用之外,还有各种衍生应用,如以太坊Ethereum、Asch等底层应用开发平台以及NXT...
  • 区块链开发详解

    2020-05-19 11:23:35
    Hyperledger fabric目前支持java,nodejs,go和python语言的sdk,供用户选择用不同的语言开发上层应用,使用相应的sdk调用部署在区块链上的链码。以下示例中我们选择使用go语言开发业务层应用。 步骤1:配置fabric ...
  • 以太坊、比特币、eos、tendermint区块链开发的精选教程,使用java、php、python、c#、go等多种语言开发区块链去中心化应用的教程。
  • 近半数开发者仅了解区块链的皮毛 作为新兴技术,区块链虽然是这几年最热门的技术话题之一...Java、Python 竟成区块链主流开发语言?! 有趣的是,在孟岩看来,即使是27%的开发者正在或是准备使用区块链,这个比例仍...
  • 区块链开发用什么语言好?

    千次阅读 2020-09-15 17:59:27
    区块链开发用什么语言最好呢? 区块链开发用什么语言最好? 区块链是一种编程思想,原则上使用任何一种编程语言都可以实现。比如:C++、Java、javascript、python、Go都可以实现开发区块链。比特币系统使用C++...
  • 链客,专为开发者而生,有问必答! 此文章来自区块链技术社区,未经允许拒绝转载。...python源代码保存在Github。 区块链 区块链是一个公开的数字账本,它按时间顺序记录比特币或其他加密货币发生的交易。 更一...
  • 40多行python代码开发一个区块链?可信吗?我们将通过Python 2动手开发实现一个迷你区块链来帮你真正理解区块链技术的核心原理。python开发区块链的源代码保存在Github。 尽管有人认为区块链目前还是不成熟的解决...
  • 作者:Boblee,人工智能硕士毕业,擅长及爱好python,基于python研究人工智能、群体智能、区块链等技术,并使用python开发前后端、爬虫等。1、私钥、公钥、地址之间的关系...
  • 区块链开发入门

    2018-04-24 10:39:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • python源代码保存在Github。区块链区块链是一个公开的数字账本,它按时间顺序记录比特币或其他加密货币发生的交易。更一般的讲,区块链是一个公共数据库,新的数据将存储在一个被称为”块“的容器中,然后块会被添加...
  • 本文介绍5个最常用的PHP区块链开发库,适合PHP开发人员在以太坊/比特币等主流区块链的对接、去中心化应用开发、量化交易算法开发等应用场景中选择使用。 1、CCXT - 支持PHP的区块链量化交易开发库 CCXT是一个支持...
  • 您将能够使用Flask微框架为区块链的不同功能创建端点,比如添加事务,然后在多个机器上运行脚本来创建一个去中心化网络。您还将了解如何构建一个简单的...Python的基础编程知识Flask微框架(用于创建区块链服务器的端点
  • (由Python大本营付费下载自视觉中国)作者 | arjuna sky kok整理 | Aholiab出品 | 区块链大本营(blockchain_camp)根据IEE...
  • 你知道区块链开发人员的两种定位吗?这是我的第一篇博客 ——可以发现的干货开发人员的两个定位 你可以检索到我的原文在github —— [ github ] 【1】 注重开发区块链的底层技术,例如:使用python或go语言区块链...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 582
精华内容 232
关键字:

python区块链开发

python 订阅