ブロックチェーンをプログラミングしてみた（後編〜プログラミング）

import hashlib
import json
from time import time
from urllib.parse import urlparse
from uuid import uuid4
import requests
from flask import Flask, jsonify, request

class Blockchain:

    ----(省略)----

    #①-2　ラストブロックリターン用クラス関数
    @property
    def last_block(self):
        return self.chain[-1]

app = Flask(__name__)    #ノードの作成

node_identifier = str(uuid4()).replace('-', '')    #ノード独自の識別子を作る

blockchain = Blockchain()    #ブロックチェーンクラスのインスタンス化(コンストラクタの発動)

#②-1 トランザクション用メソッド
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    values = request.get_json(force=True)         #(Reponse)POSTされたトランザクションデータを解析

    #POSTされたトランザクションが有効か確認
    required = ['sender', 'recipient', 'amount']  #(リスト)トランザクションの定義
    if not all(k in values for k in required):
        return 'Missing values', 400
    index = blockchain.new_transaction(values['sender'],values['recipient'], values['amount'])
     #<int>クラスメソッド(#①-3)の実行

    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

class Blockchain:
    #①-1 コンストラクタ
    def __init__(self):
        self.current_transactions = []     #①-1-1(リスト( ブロックに格納されていないトランザクションリスト

    ・・・(省略)・・・

    #<トランザクション用メソッド>
    #①-3　トランザクション追加用クラスメソッド
    def new_transaction(self, sender, recipient, amount):
        """
        作業内容:次のブロックに入るトランザクションの一覧を作成(トランザクションが実行されるごとに追加されていく)
        :param sender: (str)送り手のアドレス
        :param recipient: (str)受け手のアドレス
        :param amount: (int)送金量
        :return: (int)このトランザクションの塊を含むブロックのインデックス
        """
　　　　 #トランザクションリストに辞書型で追加(①-1-1)
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
        return self.last_block['index'] + 1 

#②-2　マイニングアルゴリズム(※一般的なものとは少し違うと思われる)
@app.route('/mine', methods=['GET'])
def mine():
    last_block = blockchain.last_block             #(リスト)直前のブロック情報の取得(①-2)
    proof = blockchain.proof_of_work(last_block)   #(int)プルーフオブワークの実行(①-4)

    blockchain.new_transaction(                    #コインベースの実行(マイニング成功者への報酬)
        sender="0",                                #「sender=0」でコインベースからの報酬であることを表す
        recipient=node_identifier,                 #受け手のアドレス
        amount=1,                                  #報酬
    )

    previous_hash = blockchain.hash(last_block)         #(str)直前のハッシュ値の計算(①-5)
    block = blockchain.new_block(proof, previous_hash)  #(dict)新しいブロックの生成(①-7)

    response = {
        'message': "New Block Forged",
        'index': block['index'],
        'transactions': block['transactions'],
        'proof': block['proof'],
        'previous_hash': block['previous_hash'],
    }
    return jsonify(response), 200

class Blockchain:
    #①-1 コンストラクタ
    def __init__(self):
        self.current_transactions = []    #①-1-1(リスト) ブロックに格納されていないトランザクションリスト
        self.chain = []                   #①-1-2(リスト) ブロックチェーンを格納するリスト

        self.new_block(previous_hash='1', proof=100)  #①-1-4 ジェネシスブロック

    ・・・(省略)・・・

    #<マイニング用メソッド>
    #①-4　プルーフオブワーク用クラス関数
    def proof_of_work(self, last_block):
        """
        作業内容:シンプルなプルーフオブワークアルゴリズム。条件を満たすプルーフを探す
        　　　　　※条件は①-6で指定
        ・具体的なフロー:⑴⑵⑶をそれぞれ求める
            　　　　   → ⑴⑵⑶を結合しハッシュ値を求める(①-5で実行)
                   　 → ハッシュ値の最初の4つが0か確認する(①-6で実行)
                    　→ 条件を満たすまで③のプルーフをなんども変更して再計算
                     ※⑴直前のブロックのプルーフ
                      ⑵直前のブロックのハッシュ値
                      ⑶今回のプルーフ
        :param last_block: (dict)last Block(from ②-2)
        :return: <int>proof
        """
        last_proof = last_block['proof']       #(int)⑴直前のブロックのプルーフ
        last_hash = self.hash(last_block)      #(str)⑵直前のハッシュ値の算出(①-5)

        proof = 0                              #(int)以下3段でプルーフを探索
        while self.valid_proof(last_proof, proof, last_hash) is False:  #①-6の戻り値
            proof += 1

        return proof

    #①-5　ハッシュ化用クラスメソッド
    @staticmethod
    def hash(block):
        """
        作業内容:ブロックのSHA-256ハッシュ値を作る
        :param block: (dict)ブロック(from ①-4)
        :return : (str)16進数のハッシュ値
        """

        block_string = json.dumps(block, sort_keys=True).encode()  #(byte(文字列のブロック➡︎Json文字列➡︎バイト型の流れ
         #※ソートすることでハッシュ値に一貫性を持たせる('sort_keys=True'辞書型データをキーでソート)
        return hashlib.sha256(block_string).hexdigest()

    #①-6　有効なプルーフを探すクラスメソッド
    @staticmethod
    def valid_proof(last_proof, proof, last_hash):
        """
        作業内容:条件を満たすハッシュ値を探す
        ・条件:ハッシュ値の最初の4つが0になる
        :param last_proof: (int)直前のブロックのプルーフ(from ①-4)
        :param proof: (int)プルーフ(from ①-4)
        :param last_hash: (str)直前のブロックのハッシュ値(from ①-4)
        :return: (bool)bool値を返す
        """
        guess = f'{last_proof}{proof}{last_hash}'.encode()   #(byte)⑴⑵⑶を連結してbyte型に変更
        guess_hash = hashlib.sha256(guess).hexdigest()       #(str)ハッシュ値の算出
        return guess_hash[:4] == "0000"

    #①-7 ブロック生成用クラス関数
    def new_block(self, proof, previous_hash):
        """
        作業内容:新しいブロックを作る
        :param proof: (int)プルーフオブワークの戻り値(from ②-2)
        :param previous_hash: (str)直前のブロックのハッシュ値(②-2)
        :return: (dict)新しいブロック
        """

        block = {                                       #辞書型で記述
            'index': len(self.chain) + 1,               #インデックス
            'timestamp': time(),                        #タイムスタンプ
            'transactions': self.current_transactions,  #トランザクション情報の取得(from ①-1)
            'proof': proof,                             #プルーフ
            'previous_hash': previous_hash or self.hash(self.chain[-1]),  #ハッシュ値(①-5)  
        }

        self.current_transactions = []     #新しいブロック用のトランザクションリストを初期化(①-1-1)

        self.chain.append(block)           #ブロックチェーンの末尾に新しいブロックを追加(①-1-2)
        return block    

#②-3　コンセンサス・アルゴリズム
@app.route('/nodes/resolve', methods=['GET'])
def consensus():
    replaced = blockchain.resolve_conflicts()        #コンセンサスアルゴリズムを実行(①-8)
    if replaced:                                     #置き換えがあった場合(①-8がTrueを返す場合)
        response = {
            'message': 'Our chain was replaced',
            'new_chain': blockchain.chain
        }
    else:                                            #置き換えがなかった場合
        response = {
            'message': 'Our chain is authoritative',
            'chain': blockchain.chain
        }
    return jsonify(response), 200


class Blockchain:

    ・・・(省略)・・・

    #<コンセンサスアルゴリズム用メソッド>
    #①–8　コンセンサスアルゴリズム
    def resolve_conflicts(self):
        """
        作業内容：他のノードからブロックチェーンをダウンロードし、長いものに置き換える
        :return: (bool)ブロックチェーンが置き換わったばいはTrue、そうでない場合はFalse
        """
        neighbours = self.nodes        #(セット)登録されたノードの情報を変数に格納(①-1-3)
        new_chain = None               #(None)チェーン比較用の変数

        max_length = len(self.chain)   #(int)自身のブロックチェーンの長さを格納(①-1-2)

        for node in neighbours:        #登録されている全てのノードを順番に以下の命令を実行
            response = requests.get(f'http://{node}/chain')  #(Response)比較するノード情報取得
            
            if response.status_code == 200:         #情報が取得できた場合
                length = response.json()['length']  #(int)比較ノードのlengthを格納
                chain = response.json()['chain']    #(int)比較ノードのchainを格納

                if length > max_length and self.valid_chain(chain):     #ブロックチェーン確認(①-9)
                    max_length = length
                    new_chain = chain

        if new_chain:        #自分のとは異なる有効なブロックチェーンがあれば自分のものと置き換え
            self.chain = new_chain
            return True

        return False         #置き換えなかった場合は、Falseを返す

    #①-9 ブロックチェーンが正しいか確認するクラスメソッド
    def valid_chain(self, chain):
        """
        作業内容：ブロックチェーンが正しいか確認する
                ①ハッシュ②プルーフの2点
        :param chain: (dict)ブロックチェーン(from ①-4)※検証先のノードから持ってきたチェーン
        :return: (bool)有効ならTrue、無効ならFalse
        """
        last_block = chain[0]       #(リスト)ブロックチェーンの1つ目から確認
        current_index = 1           #(int)

        while current_index < len(chain):  #「インデックス番号=チェーンの長さ」となるまで下記実行文の繰り返し
            block = chain[current_index]   #<リスト>現在のブロック(last_blockはこの1つ目のブロック)
            print(f'{last_block}')
            print(f'{block}')
            print("\n-----------\n")

            if block['previous_hash'] != self.hash(last_block): #ハッシュ値の照合
                return False                                   　#一致しない場合

            if not self.valid_proof(last_block['proof'], block['proof'],  #プルーフを照合(①-6)
                                    last_block['previous_hash']):
                return False
            last_block = block     #1つのブロックの照合が問題なく終わったら、次のブロックの照合へ進む
            current_index += 1
            
        return True                #全部のブロックが有効ならTrueを返す

#②-4　ノード登録メソッド
@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values = request.get_json(force=True)        #POSTされたJsonファイルを解析(mimeタイプで判断)
    
    nodes = values.get('nodes')                  #values→Responseオブジェクト
    if nodes is None:                            #ノードがない場合
        return "Error: Please supply a valid list of nodes", 400

    for node in nodes:                           #ノードがある場合、ノードを登録
        blockchain.register_node(node)           #ノードに登録する(①-10)

    response = {
        'message': 'New nodes have been added',
        'total_nodes': list(blockchain.nodes),
    }
    return jsonify(response), 201


class Blockchain:

    ・・・(省略)・・・

    #<ノードの登録用メソッド>
    #①-10　新しいノードの登録
    def register_node(self, address):
        """
        作業内容:ノードリストに新しいノードリストを登録する
        :param address: (str)ノードのアドレス(from ②-4)
                        例）'http://192.168.0.5:5000'
        :return : None
        """
        parsed_url = urlparse(address)               #(タプル)addressを解析
        if parsed_url.netloc:                        #netloc属性値
            self.nodes.add(parsed_url.netloc)        #①-1-3
        elif parsed_url.path:                        #path属性値('192.168.0.5:5000'など)
            self.nodes.add(parsed_url.path)          #①-1-3
        else:                                         #それ以外の場合
            raise ValueError('Invalid URL')           #ValueErrorを返す

#②-5　全てのブロックチェーンを返すメソッド
@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,          #ブロックチェーンの一覧(①-1-2)
        'length': len(blockchain.chain),    #ブロックチェーンの長さ(①-1-2)
    }
    return jsonify(response), 200

#②-6　起動用
if __name__ == '__main__':
    from argparse import ArgumentParser     #以下の5行でコマンドラインでノードを増やせるようにしている。
    parser = ArgumentParser()
    parser.add_argument('-p', '--port', default=5000, type=int, help='port to listen on')
    args = parser.parse_args()
    port = args.port

    app.run(host='0.0.0.0', port=port, debug=True)