Analysez la blockchain en détail grâce aux fonctions Python

Le contenu de cet article concerne l'analyse détaillée de la blockchain via les fonctions Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Je pense que pour beaucoup de gens, la blockchain est un tel phénomène qu'il est difficile de ne pas avoir la tête qui tourne. J'ai commencé à regarder des vidéos et à lire des articles, mais pour moi personnellement, je n'ai pas vraiment compris de quoi il s'agissait ni quelles étaient ses applications potentielles jusqu'à ce que j'écrive ma propre blockchain simple.

Mon point de vue sur la blockchain est qu'il s'agit d'une base de données publique cryptée. Si vous étiez Amazon et que vous vouliez utiliser la technologie pour suivre les niveaux de stocks, serait-il logique d’utiliser la blockchain ? Probablement pas, car vos clients ne veulent pas dépenser de ressources pour vérifier votre blockchain parce qu'ils regardent simplement le site Web et disent Only 1 left!.

Je vous laisse réfléchir aux futures candidatures. Alors sans plus attendre, jetons un œil à nos 7 fonctions !

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()

Le cœur de la blockchain est la fonction de hachage. Sans cryptage, la blockchain serait facile à exploiter et les transactions pourraient être écrites de manière frauduleuse.

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 consiste à enregistrer à qui appartient les transactions de jetons. Par exemple, j'ai 10 jetons et j'en donne 1 à Medium, alors le statut state sera la valeur du dictionnaire ci-dessous.

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

Il est à noter que le découvert n'est pas possible. Je ne peux pas donner 11 jetons à quelqu'un s'il n'y a que 10 jetons disponibles. La fonction suivante vérifie que la transaction que nous essayons d'effectuer est bien valide. De plus, la transaction doit être globalement équilibrée. Je ne peux pas donner 5 jetons et demander au destinataire de recevoir 4 jetons car cela détruirait et générerait les jetons.

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

Maintenant, nous pouvons fabriquer nos blocs. Les informations du bloc précédent sont lues et utilisées pour les lier au nouveau bloc. C’est aussi le cœur du concept blockchain. Il est possible d’insérer de manière trompeuse des transactions apparemment valides dans la blockchain, mais il est (presque) impossible sur le plan informatique de déchiffrer tous les blocs précédents, ce qui préserve l’intégrité de la blockchain.

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}

Voici une petite fonction d'aide pour vérifier le hachage du bloc précédent :

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

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

    return

Une fois que nous avons tout réuni, il est temps de créer notre bloc. Nous allons maintenant mettre à jour la blockchain.

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

Avant de pouvoir terminer, la blockchain doit être vérifiée :

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

Enfin, une fonction de transaction est nécessaire, qui suspend tout ce qui précède :

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

Donc, nous avons maintenant 7 fonctions. Comment interagissons-nous avec lui ? Eh bien, nous devons d'abord démarrer notre blockchain avec Genesis Block. C'est le début de notre nouveau jeton (ou inventaire, etc.). Pour les besoins de cet article, je dirai que je suis Tom et que je commencerai avec 10 jetons.

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}

Maintenant, regardez ce qui se passe lorsque je donne des jetons à Medium :

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

stateMise à jour pour montrer à qui appartient combien de jetons :

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

La blockchain ressemble à ceci :

[{'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'}]

Nous créons la première nouvelle transaction et l'insérons en haut de la pile. Maintenant, j'espère avoir piqué votre curiosité et votre intérêt à copier le code et à jouer avec.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!