Analysieren Sie die Blockchain im Detail mit Python-Funktionen

Der Inhalt dieses Artikels befasst sich mit der detaillierten Analyse der Blockchain mithilfe von Python-Funktionen. Freunde in Not können darauf verweisen.

Ich denke, für viele Leute da draußen ist Blockchain ein solches Phänomen, dass es schwer ist, ihnen nicht den Kopf zu verdrehen. Ich fing an, Videos anzuschauen und Artikel zu lesen, aber ich persönlich verstand nicht wirklich, was es war und welche möglichen Anwendungen es hatte, bis ich meine eigene einfache Blockchain schrieb.

Meiner Ansicht nach handelt es sich bei der Blockchain um eine öffentliche, verschlüsselte Datenbank. Wenn Sie Amazon wären und die Technologie zur Verfolgung von Lagerbeständen nutzen wollten, wäre es dann sinnvoll, Blockchain zu verwenden? Wahrscheinlich nicht, denn Ihre Kunden möchten keine Ressourcen für die Verifizierung Ihrer Blockchain aufwenden, weil sie einfach auf die Website schauen und Only 1 left! sagen.

Ich lasse Sie über zukünftige Bewerbungen nachdenken. Werfen wir also ohne weitere Umschweife einen Blick auf unsere 7 Funktionen!

def hash_function(k):
    """Hashes our transaction."""
    if type(k) is not str:
        k = json.dumps(k, sort_keys=True)

    return hashlib.sha256(k).hexdigest()

Der Kern der Blockchain ist die Hash-Funktion. Ohne Verschlüsselung wäre die Blockchain einfach zu bedienen und Transaktionen könnten betrügerisch geschrieben werden.

def update_state(transaction, state):
    state = state.copy()

    for key in transaction:
        if key in state.keys():
            state[key] += transaction[key]
        else:
            state[key] = transaction[key]

    return state

state besteht darin, aufzuzeichnen, wem die Token-Transaktionen gehören. Wenn ich zum Beispiel 10 Token habe und 1 an Medium gebe, dann ist der Status state der Wert des Wörterbuchs unten.

{‘transaction’: {‘Tom’: 9, ‘Medium’: 1}}

Es ist zu beachten, dass eine Überziehung nicht möglich ist. Ich kann niemandem 11 Token geben, wenn nur 10 Token verfügbar sind. Die folgende Funktion überprüft, ob die Transaktion, die wir durchführen möchten, tatsächlich gültig ist. Darüber hinaus muss die Transaktion insgesamt ausgeglichen sein. Ich kann nicht 5 Token geben und dafür sorgen, dass der Empfänger 4 Token erhält, weil das die Token zerstören und generieren würde.

def valid_transaction(transaction, state):
    """A valid transaction must sum to 0."""
    if sum(transaction.values()) is not 0:
        return False

    for key in transaction.keys():
        if key in state.keys():
            account_balance = state[key]
        else:
            account_balance = 0

        if account_balance + transaction[key] < 0:
            return False

    return True

Jetzt können wir unseren Block erstellen. Die Informationen aus dem vorherigen Block werden gelesen und zur Verknüpfung mit dem neuen Block verwendet. Dies ist auch der Kern des Blockchain-Konzepts. Es ist möglich, scheinbar gültige Transaktionen täuschend in die Blockchain einzufügen, es ist jedoch rechnerisch (fast) unmöglich, alle vorherigen Blöcke zu entschlüsseln, wodurch die Integrität der Blockchain gewahrt bleibt.

def make_block(transactions, chain):
    """Make a block to go into the chain."""
    parent_hash = chain[-1]['hash']
    block_number = chain[-1]['contents']['block_number'] + 1

    block_contents = {
        'block_number': block_number,
        'parent_hash': parent_hash,
        'transaction_count': block_number + 1,
        'transaction': transactions
    }

    return {'hash': hash_function(block_contents), 'contents': block_contents}

Hier ist eine kleine Hilfsfunktion, um den Hash des vorherigen Blocks zu überprüfen:

def check_block_hash(block):
    expected_hash = hash_function(block['contents'])

    if block['hash'] is not expected_hash:
        raise

    return

Sobald wir alles zusammen haben, ist Zeit, unseren Block zu erstellen. Wir werden nun die Blockchain aktualisieren.

def check_block_validity(block, parent, state):
    parent_number = parent['contents']['block_number']
    parent_hash = parent['hash']
    block_number = block['contents']['block_number']

    for transaction in block['contents']['transaction']:
        if valid_transaction(transaction, state):
            state = update_state(transaction, state)
        else:
            raise

    check_block_hash(block)  # Check hash integrity

    if block_number is not parent_number + 1:
        raise

    if block['contents']['parent_hash'] is not parent_hash:
        raise

    return state

Bevor wir fertig sind, muss die Blockchain überprüft werden:

def check_chain(chain):
    """Check the chain is valid."""
    if type(chain) is str:
        try:
            chain = json.loads(chain)
            assert (type(chain) == list)
        except ValueError:
            # String passed in was not valid JSON
            return False
    elif type(chain) is not list:
        return False

    state = {}

    for transaction in chain[0]['contents']['transaction']:
        state = update_state(transaction, state)

    check_block_hash(chain[0])
    parent = chain[0]

    for block in chain[1:]:
        state = check_block_validity(block, parent, state)
        parent = block

    return state

Schließlich wird eine Transaktionsfunktion benötigt, die alle oben genannten Punkte aufhängt:

def add_transaction_to_chain(transaction, state, chain):
    if valid_transaction(transaction, state):
        state = update_state(transaction, state)
    else:
        raise Exception('Invalid transaction.')

    my_block = make_block(state, chain)
    chain.append(my_block)

    for transaction in chain:
        check_chain(transaction)

    return state, chain

Also, Jetzt haben wir 7 Funktionen. Wie interagieren wir damit? Nun, zuerst müssen wir unsere Blockchain mit Genesis Block starten. Dies ist der Beginn unseres neuen Tokens (oder Inventars usw.). Zum Zweck dieser Erklärung werde ich sagen, dass ich Tom bin und mit 10 Token beginnen werde.

genesis_block = {
    'hash': hash_function({
        'block_number': 0,
        'parent_hash': None,
        'transaction_count': 1,
        'transaction': [{'Tom': 10}]
    }),
    'contents': {
        'block_number': 0,
        'parent_hash': None,
        'transaction_count': 1,
        'transaction': [{'Tom': 10}]
    },
}

block_chain = [genesis_block]
chain_state = {'Tom': 10}

Sehen Sie sich nun an, was passiert, wenn ich ein paar Token an Medium gebe:

chain_state, block_chain = add_transaction_to_chain(transaction={'Tom': -1, 'Medium': 1}, state=chain_state, chain=block_chain)

stateAktualisiert, um zu zeigen, wer wie viele Token besitzt:

{'Medium': 1, 'Tom': 9}

Die Blockchain sieht so aus Dies:

[{'contents': {'block_number': 0,
               'parent_hash': None,
               'transaction': [{'Tom': 10}],
               'transaction_count': 1},
  'hash': '064d0b480b3b92761f31831d30ae9f01954efaa62371b4b44f11465ec22abe93'},
 {'contents': {'block_number': 1,
               'parent_hash': '064d0b480b3b92761f31831d30ae9f01954efaa62371b4b44f11465ec22abe93',
               'transaction': {'Medium': 1, 'Tom': 9},
               'transaction_count': 2},
  'hash': 'b4ae25f0cc0ee0b0caa66b9a3473e9a108652d53b1dc22a40962fef5c8c0f08c'}]

Wir erstellen die erste neue Transaktion und fügen sie oben im Stapel ein. Nun hoffe ich, dass ich Ihre Neugier und Ihr Interesse geweckt habe, den Code zu kopieren und damit zu spielen.

Das obige ist der detaillierte Inhalt vonAnalysieren Sie die Blockchain im Detail mit Python-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!