Статья на тему Как создать собственную криптовалюту с пом...

С ростом числа криптовалют, blockchain создает шум в мире технологий. Эта технология привлекла так много внимания главным образом благодаря своей способности гарантировать безопасность, обеспечивать децентрализацию и ускорять процессы в нескольких отраслях, особенно в финансовой.

 

По сути, блокчейн является публичной базой данных, которая необратимо документирует и подтверждает подлинность владения и передачи цифровых активов. Цифровые валюты, такие как Биткойн и Эфириум, основаны на этой концепции. Блокчейн - это захватывающая технология, которую вы можете использовать для преобразования возможностей ваших приложений.

В последнее время мы наблюдаем, как правительства, организации и отдельные лица используют технологию блокчейна для создания своих собственных криптовалют и не оставляют их позади. Примечательно, что когда Facebook предложил свою собственную криптовалюту под названием Libra , это объявление всколыхнуло многие воды по всему миру.

Что если бы вы могли последовать их примеру и создать свою собственную версию криптовалюты?

Я подумал об этом и решил разработать алгоритм, который создает криптографию.

Я решил назвать криптовалюту fccCoin .

В этом уроке я собираюсь проиллюстрировать пошаговый процесс, который я использовал для создания цифровой валюты (я использовал объектно-ориентированные концепции языка программирования Python ).

Вот основная схема алгоритма блокчейна для создания fccCoin :

 def construct_block(self, proof_no, prev_hash):
        # constructs a new block and adds it to the chain
        pass

    @staticmethod
    def check_validity():
        # checks whether the blockchain is valid
        pass

    def new_data(self, sender, recipient, quantity):
        # adds a new transaction to the data of the transactions
        pass

    @staticmethod
    def construct_proof_of_work(prev_proof):
        # protects the blockchain from attack
        pass
   
    @property
    def last_block(self):
        # returns the last block in the chain
        return self.chain[-1]

Теперь позвольте мне объяснить, что происходит ...

1. Строительство первого блочного класса
Блокчейн состоит из нескольких блоков, которые соединены друг с другом (звучит знакомо, правда?).

Цепочка блоков происходит таким образом, что если вмешивается один блок, остальная часть цепочки становится недействительной.

Применяя вышеуказанную концепцию, я создал следующий класс начальных блоков:

import time

class Block:

    def __init__(self, index, proof_no, prev_hash, data, timestamp=None):
        self.index = index
        self.proof_no = proof_no
        self.prev_hash = prev_hash
        self.data = data
        self.timestamp = timestamp or time.time()

    @property
    def calculate_hash(self):
        block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no,
                                              self.prev_hash, self.data,
                                              self.timestamp)

Как видно из приведенного выше кода, я определил функцию __init __ () , которая будет выполняться при инициализации класса Block , как и в любом другом классе Python.

Я предоставил следующие параметры функции инициализации:

self - это относится к экземпляру класса Block , позволяя получить доступ к методам и атрибутам, связанным с классом;
индекс - это отслеживает положение блока в блокчейне;
proof_no - это число, создаваемое при создании нового блока (называемого майнингом);
prev_hash - это относится к хэшу предыдущего блока в цепочке;
данные - это запись всех выполненных транзакций, например, купленное количество;
метка времени - это метка времени для транзакций.
Второй метод в классе Calculate_hash сгенерирует хэш блоков, используя вышеуказанные значения. Модуль SHA-256 импортируется в проект, чтобы помочь в получении хэшей блоков.

После того, как значения были введены в криптографический алгоритм хеширования, функция вернет 256-битную строку, представляющую содержимое блока.

Вот как достигается безопасность в цепочках блоков - каждый блок будет иметь хэш, и этот хэш будет опираться на хэш предыдущего блока.

Таким образом, если кто-то попытается скомпрометировать какой-либо блок в цепочке, другие блоки будут иметь недопустимые хеши, что приведет к нарушению всей сети цепочки блоков.

В конечном итоге блок будет выглядеть так:

{
    "index": 2,
    "proof": 21,
    "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823",
    "transactions": [
        {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}
    ],
    "timestamp": 1521646442.4096143
}

       

2. Создание класса Blockchain
Основная идея блокчейна, как следует из названия, заключается в «сцеплении» нескольких блоков друг с другом.

Поэтому я собираюсь создать класс Blockchain, который будет полезен для управления работой всей цепочки. Именно здесь будет происходить большинство действий.

Класс Blockchain будет иметь различные вспомогательные методы для выполнения различных задач в блокчейне.

Позвольте мне объяснить роль каждого из методов в классе.

а. Метод конструктора
Этот метод гарантирует создание блокчейна.

class BlockChain:

    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.construct_genesis()

Вот роли его атрибутов:

self.chain - эта переменная хранит все блоки;
self.current_data - эта переменная хранит все завершенные транзакции в блоке;
self.construct_genesis () - этот метод позаботится о создании начального блока.
б. Построение блока генезиса
Блокчейн требует метода construct_genesis для построения начального блока в цепочке. В соглашении блокчейнов этот блок является особенным, потому что он символизирует начало блокчейна.

В этом случае давайте создадим его, просто передав некоторые значения по умолчанию методу construct_block .

Я дал и proof_no, и prev_hash значение ноль, хотя вы можете указать любое значение.

def construct_genesis(self):
    self.construct_block(proof_no=0, prev_hash=0)

def construct_block(self, proof_no, prev_hash):
    block = Block(
        index=len(self.chain),
        proof_no=proof_no,
        prev_hash=prev_hash,
        data=self.current_data)
    self.current_data = []

    self.chain.append(block)
    return block

с. Строительство новых блоков

Метод construct_block используется для создания новых блоков в блокчейне.

Вот что происходит с различными атрибутами этого метода:

индекс - это представляет длину блокчейна;
proof_nor & prev_hash - метод вызывающей стороны передает их;
data - содержит запись всех транзакций, которые не включены ни в один блок на узле;
self.current_data - используется для сброса списка транзакций на узле. Если блок создан и транзакции выделены для него, список сбрасывается, чтобы гарантировать, что будущие транзакции будут добавлены в этот список. И этот процесс будет происходить непрерывно;
self.chain.append () - этот метод объединяет вновь созданные блоки в цепочку;
return - наконец, сконструированный блочный объект возвращается.
д. Проверка действительности

Метод check_validity важен для оценки целостности блокчейна и обеспечения отсутствия аномалий.

Как упоминалось ранее, хеши необходимы для безопасности блокчейна, так как даже малейшее изменение объекта приведет к генерации совершенно нового хэша.

Поэтому этот метод check_validity использует операторы if для проверки правильности хеша каждого блока.

Он также проверяет, указывает ли каждый блок на предыдущий справа, сравнивая значение их хэшей. Если все правильно, он возвращает истину; в противном случае возвращается false.

@staticmethod
def check_validity(block, prev_block):
    if prev_block.index + 1 != block.index:
        return False

    elif prev_block.calculate_hash != block.prev_hash:
        return False

    elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no):
        return False

    elif block.timestamp <= prev_block.timestamp:
        return False

    return True

е. Добавление данных транзакций

Метод new_data используется для добавления данных транзакций в блок. Это очень простой метод: он принимает три параметра (данные отправителя, данные получателя и количество) и добавляет данные транзакции в список self.current_data .

Каждый раз, когда создается новый блок, этот список выделяется этому блоку и сбрасывается еще раз, как объяснено в методе construct_block .

Как только данные транзакции были добавлены в список, возвращается индекс следующего блока, который будет создан.

Этот индекс рассчитывается путем добавления 1 к индексу текущего блока (который является последним в блокчейне). Данные помогут пользователю отправить транзакцию в будущем.

def new_data(self, sender, recipient, quantity):
    self.current_data.append({
        'sender': sender,
        'recipient': recipient,
        'quantity': quantity
    })
    return True

е. Добавление доказательства работы

Доказательство работы - это концепция, которая предотвращает злоупотребление блокчейном. Проще говоря, его целью является определение числа, которое решает проблему после выполнения определенного объема вычислительной работы.

Если уровень сложности определения номера высок, это препятствует рассылке спама и подделке блокчейна.

В этом случае мы будем использовать простой алгоритм, который отговаривает людей от майнинга блоков или создания блоков легко.

@staticmethod
def proof_of_work(last_proof):
    '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes
         f is the previous f'
         f' is the new proof
        '''
    proof_no = 0
    while BlockChain.verifying_proof(proof_no, last_proof) is False:
        proof_no += 1

    return proof_no

@staticmethod
def verifying_proof(last_proof, proof):
    #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?

    guess = f'{last_proof}{proof}'.encode()
    guess_hash = hashlib.sha256(guess).hexdigest()
    return guess_hash[:4] == "0000"

Получение последнего блока

Наконец, метод latest_block - это вспомогательный метод, который помогает получить последний блок в цепочке блоков. Помните, что последний блок на самом деле является текущим блоком в цепочке

@property
    def latest_block(self):
        return self.chain[-1]

Давайте подведем итоги

Вот весь код для создания криптовалюты fccCoin .

      return proof_no

    @staticmethod
    def verifying_proof(last_proof, proof):
        #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?

        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

    @property
    def latest_block(self):
        return self.chain[-1]

    def block_mining(self, details_miner):

        self.new_data(
            sender="0",  #it implies that this node has created a new block
            receiver=details_miner,
            quantity=
            1,  #creating a new block (or identifying the proof number) is awarded with 1
        )

        last_block = self.latest_block

        last_proof_no = last_block.proof_no
        proof_no = self.proof_of_work(last_proof_no)

        last_hash = last_block.calculate_hash
        block = self.construct_block(proof_no, last_hash)

        return vars(block)

    def create_node(self, address):
        self.nodes.add(address)
        return True

    @staticmethod
    def obtain_block_object(block_data):
        #obtains block object from the block data

        return Block(
            block_data['index'],
            block_data['proof_no'],
            block_data['prev_hash'],
            block_data['data'],
            timestamp=block_data['timestamp'])

Теперь давайте проверим наш код, чтобы увидеть, работает ли он.

blockchain = BlockChain()

print("***Mining fccCoin about to start***")
print(blockchain.chain)

last_block = blockchain.latest_block
last_proof_no = last_block.proof_no
proof_no = blockchain.proof_of_work(last_proof_no)

blockchain.new_data(
    sender="0",  #it implies that this node has created a new block
    recipient="Quincy Larson",  #let's send Quincy some coins!
    quantity=
    1,  #creating a new block (or identifying the proof number) is awarded with 1
)

last_hash = last_block.calculate_hash
block = blockchain.construct_block(proof_no, last_hash)

print("***Mining fccCoin has been successful***")
print(blockchain.chain)

Это сработало!

Вот результат процесса добычи:

***Mining fccCoin about to start***
[0 - 0 - 0 - [] - 1566930640.2707076]
***Mining fccCoin has been successful***
[0 - 0 - 0 - [] - 1566930640.2707076, 1 - 88914 - a8d45cb77cddeac750a9439d629f394da442672e56edfe05827b5e41f4ba0138 - [{'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}] - 1566930640.5363243]
   

Заключение

Вот оно!

Вот как вы можете создать свой собственный блокчейн, используя Python.

Позвольте мне сказать, что этот урок только демонстрирует основные концепции для того, чтобы намочить ноги в инновационной технологии блокчейна.

Если бы эта монета была развернута как есть, она не смогла бы удовлетворить нынешние требования рынка в отношении стабильной, безопасной и простой в использовании криптовалюты.

Поэтому его все еще можно улучшить, добавив дополнительные функции для расширения его возможностей по майнингу и отправке финансовых транзакций .

Тем не менее, это хорошая отправная точка, если вы решите сделать свое имя известным в удивительном мире крипто.

Удачного (крипто) кодирования!