Как написать блокчейн приложение - Правописание и грамматика

Самый быстрый способ изучить работу Блокчейнов – это создать свой блокчейн. Стоит лишь только попробовать!

Скорее всего вы здесь, также, как и я, потому что были недовольны резким подъемом Криптовалюты. И вы хотите узнать, как же работают Блокчейны – фундаментальная технология, которая стоит за всеми криптовалютами.

Но понять, как работают Блокчейны не так просто – ну или, как минимум для меня, это сложно. Я с трудом пробирался сквозь множество непонятных видеороликов, сомнительных туториалов и боролся с сильным разочарованием от очень малого количества примеров. Поэтому мы с вами напишем свой блокчейн.

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

Перед тем как мы начнем…

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

Если вы не уверены в том, что такое хэш, то вот объяснение.

На кого нацелен данный туториал?

У вас не должно возникать трудностей с чтением синтаксиса и написанием базовых вещей на Python. Кроме того, у вас должно быть понимание того, как работают HTTP-запросы, поскольку обращаться к нашему Блокчейну мы будем именно через них.

Что вам необходимо?

Убедитесь в том, что у вас установлен Python 3.6+ (также как и pip). Вам также необходимо установить библиотеку Flask и прекрасную библиотеку Request:

pip install Flask==0.12.2 requests==2.18.4

О, вам также понадобится HTTP-клиент, наподобие Postman или cURL. Но все будет дальше.

Где можно найти окончательную версию?

Исходный код будет доступен здесь.

…

Шаг 1: Создаем свой блокчейн

Запустите ваш любимый редактор кода или IDE, лично мне нравится PyCharm. Создайте новый файл с названием blockchain.py. Мы будем использовать только один файл, но если вы вдруг запутаетесь, то всегда можете обратиться к исходному коду.

Представление Блокчейна

Создадим класс Blockchain, конструктор которого будет создавать изначально пустой список (для хранения нашего блокчейна), и еще один для хранения транзакций. Ниже приведен макет нашего класса:

 	
class Blockchain(object):	
    def __init__(self):
        self.chain = []
        self.current_transactions = []
 	
    def new_block(self):
        # Создает новый Блок и добавляет его к цепочке
        pass

 	
    def new_transaction(self):
        # Добавляет новую транзакцию к списку транзакций
        pass
 	
    @staticmethod	
    def hash(block):
        # Хэшируем блоки
        pass
 	

    @property
    def last_block(self):
        # Возвращает последний блок в цепочке
        pass

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

Что из себя представляет Блок?

Каждый блок содержит в себе индекс, временную метку (timestamp, по Unix времени), список транзакций, доказательность (proof, подробнее об этом позже) и хэш предыдущего Блока.

Далее приведен пример того, как выглядит отдельный Блок:

block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5, 	
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

На данном этапе идея цепочки должна быть очевидна – каждый новый блок внутри себя содержит хэш предыдущего Блока. Именно наличие предыдущего хэша является решающим фактором, который делает блокчейны неизменяемыми. Если хакер повредит один из начальных блоков (любой предыдущий блок), то вся последовательность блоков будет содержать в себе некорректный хэш.

Какой в этом смысл? Если это не так, то потребуется некоторое количество времени для того, чтобы понять, что вообще происходит – это и есть ключевая идея блокчейнов.

Добавление транзакций в блок

Итак, нам понадобится способ добавления транзакций в блок. Наш метод new_transaction() отвечает за это, и он довольно простой:

class Blockchain(object):
    ...

    def new_transaction(self, sender, recipient, amount):
        """
      Создает новую транзакцию для того чтобы перейти к следующему искомому Блоку

        :параметр sender: <str> Адрес отправителя
        :параметр recipient: <str> Адрес получателя	
        :параметр amount: <int> Количество
        :return: <int> Индекс Блока, в котором будет хранится данная транзакция
        """

        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
 	
        return self.last_block['index'] + 1

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

Создание новых блоков, чтобы реализовать свой блокчейн

После того, как мы создали экземпляр нашего Блокчейна, нам необходимо заполнить его исходным блоком – блок у которого нет предшественников. Также нам необходимо добавить «proof» в наш исходный блок, который является результатом анализа (или алгоритма «доказательство выполнения работы»). По поводу анализа мы поговорим позднее.

Кроме этого, для создания исходного блока в нашем конструкторе, нам также необходимо добавить следующие методы: new_block(), new_transaction() и hash():

import hashlib	
import json
	
from time import time


 	
class Blockchain(object):	
    def __init__(self):
        """
        Инициализируем свой блокчейн
        """
        self.current_transactions = []
        self.chain = []


        # Create the genesis block
        self.new_block(previous_hash=1, proof=100)


    def new_block(self, proof, previous_hash=None):
        """
        Создаем новый блок в нашем Блокчейне

 	 	
        :параметр proof: <int> proof полученный после использования алгоритма «Доказательство выполнения работы»
        :параметр previous_hash: (Опциональный) <str> Хэш предыдущего Блока
        :return: <dict> New Block
        """

        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

 	
        # Сбрасываем текущий список транзакций
        self.current_transactions = []

 	
        self.chain.append(block)
        return block
 	
    def new_transaction(self, sender, recipient, amount):
        """
        Создает новую транзакцию для перехода к следующему замайненному Блоку

        :param sender: <str> Address of the Sender
        :param recipient: <str> Address of the Recipient
        :param amount: <int> Amount
        :return: <int> Индекс блока который будет хранить в себе эту транзакцию
        """

        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
 	
        return self.last_block['index'] + 1
 	
    @property
    def last_block(self):
        return self.chain[-1]

    @staticmethod
    def hash(block):
        """
        Создает a SHA-256 хэш блока

        :параметр block: <dict> Блок
        :return: <str>
        """

        # Мы должны быть уверены что наш Словарь упорядочен, или мы можем непоследовательные хэши
        block_string = json.dumps(block, sort_keys=True).encode()	
        return hashlib.sha256(block_string).hexdigest()

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

Разбираемся с алгоритмом «Доказательство выполнения работы»

Алгоритм «Доказательство выполнения работы» (PoW) – это то, как новые блоки создаются или майнятся в блокчейне. Целью алгоритма PoW является нахождение такого числа (метки), которое будет решать проблему. Число должно быть таким, чтобы его было сложно найти и легко проверить. Говоря в вычислительном отношении не важно кем в сети это может быть сделано. В этом и заключается основная идея данного алгоритма.

Итак, давайте взглянем на простой пример, которой поможет нам во всем разобраться.

Предположим, что хэш некоторого целочисленного числа x, умноженного на другое целочисленное число y, должен заканчиваться на 0. Следовательно, hash(x * y) = ac23dc…0. И для нашего упрощенного примера исправим x на 5. Реализуем это в Python:

from hashlib import sha256


x = 5
y = 0  # Пока мы не знаем каким должен быть y


while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
    y += 1


print(f'The solution is y = {y}')

Решением здесь будет y=21. Поскольку полученный хэш заканчивается на 0:

hash(5 * 21) = 1253e9373e...5e3600155e860

В сфере Биткоинов, алгоритм «Доказательство выполнения работы» называется Hashcash. И он не сильно отличается от нашего базового примера выше. Это алгоритм, который майнеры используют в гонке по решению задачи создания новых блоков. Как правило, сложность определяется количеством символов, которые необходимо обнаружить в строке. После чего майнеры получают награду за свое решение в качестве биткойна при транзакции.

Сеть может легко проверить их решение.

Реализация простого алгоритма PoW

Давайте реализуем простой алгоритм для того, чтобы реализовать свой блокчейн. Наше правило будет аналогично приведенному выше примеру:

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

import hashlib	
import json

 		
from time import time	
from uuid import uuid4

	
class Blockchain(object):	
    ...

    def proof_of_work(self, last_proof):
        """
        Простой алгоритм Proof of Work:
         - Ищем число p' такое, чтобы hash(pp') содержал в себе 4 лидирующих нуля, где p это предыдущий p'
         - p это предыдущий proof, а p' это новый proof

        :параметр last_proof: <int>
        :return: <int>
        """

        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1

        return proof


    @staticmethod
    def valid_proof(last_proof, proof):
        """
        Проверяем Proof: Содержит ли hash(last_proof, proof) 4 лидирующих нуля?

        :параметр last_proof: <int> предыдущий Proof
        :параметр proof: <int> Тукущий Proof
        :return: <bool> True если все верно, иначе False.
        """
	
        guess = f'{last_proof}{proof}'.encode()	
        guess_hash = hashlib.sha256(guess).hexdigest() 	
        return guess_hash[:4] == "0000"

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

Наш класс практически готов, и мы готовы начать взаимодействовать с ним посредствам HTTP-запросов.

…

Шаг 2: Свой блокчейн в качестве API

Мы будем использовать фреймворк Flask. Данный микро-фреймворк упрощает размещение конечных точек (endpoints) в Python-функциях. Это позволит нам обращаться к нашему блокчейну за счет веб-соединения с помощью HTTP-запросов.

Создадим три метода:

/transactions/new для создания новой транзакции в блоке;
/mine для передачи нашему серверу информации о том, что пора майнить новый блок;
/chain для возврата всего Блокчейна.

Настраиваем Flask для того, чтобы реализовать свой блокчейн

Наш «сервер» будет формировать одиночный узел в нашей блокчейн-сети. Давайте напишем некоторый шаблонный код:

import hashlib	
import json
	
from textwrap import dedent 	
from time import time	
from uuid import uuid4

	
from flask import Flask

	
class Blockchain(object):	
    ...

 	
# Создаем экземпляр нашего узла	
app = Flask(__name__)
 	
# Генерируем уникальный глобальный адрес для этого узла	
node_identifier = str(uuid4()).replace('-', '')

# Создаем экземпляр Blockchain	
blockchain = Blockchain()

 	
@app.route('/mine', methods=['GET']) 	
def mine():
    return "We'll mine a new Block"
 	
@app.route('/transactions/new', methods=['POST'])	
def new_transaction():
    return "We'll add a new transaction"

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }	
    return jsonify(response), 200
 	
if __name__ == '__main__':	
    app.run(host='0.0.0.0', port=5000)

Небольшое пояснение того, что мы добавили в примере выше:

Строка 15: Создаем экземпляр узла. Более подробно узнать о Flask можно здесь.
Строка 18: Генерируем случайное имя для нашего узла;
Строка 21: Создаем экземпляр класса Blockchain;
Строки 24-26: Создаем endpoint для метода /mine, который является GET-запросом;
Строки 28-30: Создаем endpoint для метода /transactions/new, который является POST-запросом, поскольку мы будем отправлять сюда данные;
Строки 32-38: Создаем endpoint для метода /chain, который будет возвращать весь Блокчейн;
Строки 40-41: Запускаем наш сервер на порт 5000.

Endpoint для транзакций

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

{
 "sender": "my address",
 "recipient": "someone else's address",
 "amount": 5
}

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

import hashlib 	
import json
	
from textwrap import dedent 	
from time import time	
from uuid import uuid4

 	
from flask import Flask, jsonify, request

...
	
@app.route('/transactions/new', methods=['POST'])	
def new_transaction():
    values = request.get_json()


    # Проверяем, что обязательные поля переданы в 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'])
 	
    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

Endpoint для майнинга

Наш endpoint майнинга – это то, где происходит магия, и в ней нет ничего сложного. Здесь совершаются три следующих вещи:

Расчет алгоритма PoW;
Майнер(ы) получают награду в виде транзакции, которая гарантируем им 1 биткойн;
Формирование нового блока, путем его добавления в цепочку.

import hashlib	
import json

 	
from time import time
from uuid import uuid4


from flask import Flask, jsonify, request
	
...
 	
@app.route('/mine', methods=['GET'])
def mine():
    # Мы запускаем алгоритм PoW для того чтобы найти следующий proof...
    last_block = blockchain.last_block	
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

 	
    # Мы должны получить награду за найденный proof.
    # Если sender = "0", то это означает что данный узел заработал биткойн.	
    blockchain.new_transaction(
        sender="0",	
        recipient=node_identifier,
        amount=1,
    )


    # Формируем новый блок, путем добавления его в цепочку
    block = blockchain.new_block(proof)
 	
    response = {
        'message': "New Block Forged",
        'index': block['index'],
        'transactions': block['transactions'],
        'proof': block['proof'],
        'previous_hash': block['previous_hash'],	
    }	
    return jsonify(response), 200

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

Шаг 3: Взаимодействие с нашим Блокчейном

Вы можете использовать простой, но уже устаревший cURL или Postman, для взаимодействия с нашим API через сеть.

Запускаем наш сервер:

$ python blockchain.py* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Давайте попробуем смайнить блок. Для этого воспользуемся GET-запросом на http://localhost:5000/mine:

Создадим новую транзакцию с помощью POST-запроса на http://localhost:5000/transactions/new с телом, содержащим структуру нашей транзакции:

Если не хотите использовать Postman, то вы можете сделать аналогичные запрос с помощью cURL:

$ curl -X POST -H "Content-Type: application/json" -d '{
 "sender": "d4ee26eee15148ee92c6cd394edd974e",
 "recipient": "someone-other-address",
 "amount": 5
}' "http://localhost:5000/transactions/new"

Я перезагрузил свой сервер, и смайнил два блока, чтобы в итоге получилось три. Давайте проверим всю цепочку, с помощью запроса на http://localhost:5000/chain:

{
  "chain": [
    {
      "index": 1,
      "previous_hash": 1,
      "proof": 100,
      "timestamp": 1506280650.770839,
      "transactions": []
    },
    {
      "index": 2,
      "previous_hash": "c099bc...bfb7",
      "proof": 35293,
      "timestamp": 1506280664.717925,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    },
    {
      "index": 3,
      "previous_hash": "eff91a...10f2",
      "proof": 35089,
      "timestamp": 1506280666.1086972,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    }
  ],
  "length": 3
}

Шаг 4: Консенсус

Пока, все что мы делали, это круто. Мы получили базовый Блокчейн, который может принимать транзакции, тем самым позволяя нам майнить новые Блоки. Однако вся суть Блокчейнов заключается в том, что они должны быть децентрализованы. Но если блокчейны децентрализованы, то как мы можем гарантировать, что все они отражают одну и ту же цепочку? Данная проблема называется проблемой Консенсуса (конфликтов). Мы реализуем алгоритм Консенсуса, если мы конечно хотим, чтобы в нашей сети было больше одного узла.

Регистрация новых узлов

Перед тем как мы сможем реализовать алгоритм Консенсуса, нам необходимо придумать способ, как наши узлы будут знать о своих «соседях» в сети. Каждый узел в нашей сети будет хранить в себе запись о других узлах в сети. Итак, нам необходимо еще некоторое количество endpoint-ов:

/nodes/register чтобы можно было принимать список новых узлов в форме URL;
/nodes/resolve для реализации нашего алгоритма Консенсуса, который разрешит любые конфликтные ситуации, чтобы каждый узел содержал корректную цепочку.

Для всего этого нам необходимо модифицировать конструктор нашего Блокчейна, и предоставить метод по регистрации узлов:

...	
from urllib.parse import urlparse	
...

 	
class Blockchain(object):
    def __init__(self):
        ...
        self.nodes = set()
        ...

    def register_node(self, address):
        """
        Добавляем новый узел в список узлов

        :параметр address: <str> Адрес узла, например: 'http://192.168.0.5:5000'
        :return: None
        """
 	
        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)

Обратите внимание, что мы использовали set() для хранения списка узлов. Это самый дешёвый способ гарантировать, что новый узлы будут добавляться, не изменяя при этом объект, то есть не важно сколько раз мы добавляли определенный узел, он появится ровно один раз.

Реализация алгоритма Консенсуса

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

...
import requests

 	
class Blockchain(object)	
    ...
 	
    def valid_chain(self, chain):
        """
        Определяем, что данный блокчейн прошел проверку
 
        :параметр chain: <list> Блокчейн
        :return: <bool> True если прошел проверку, иначе False
        """

        last_block = chain[0]
        current_index = 1
 	
        while current_index < len(chain):
            block = chain[current_index]
            print(f'{last_block}')	
            print(f'{block}')
            print("n-----------n")
            # Проверяем, что хэш этого блока корректен
            if block['previous_hash'] != self.hash(last_block):
                return False

            # Проверяем, что алгоритм PoW корректен
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

 	
            last_block = block
 	
            current_index += 1

        return True

    def resolve_conflicts(self):
        """
        Это наш алгоритм Консенсуса, он разрешает конфликт путём
        замены нашей цепочки на самую длинную в нашей сети.

        :return: <bool> True если наша цепочка была заменена, False если это не так
        """

 	
        neighbours = self.nodes
        new_chain = None

        # Мы ищем цепочки длиннее наших
        max_length = len(self.chain)

        # Берем все цепочки со всех узлов нашей сети и проверяем их
        for node in neighbours:
            response = requests.get(f'http://{node}/chain')
 	
            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']

                # Проверяем, что цепочка имеет 
                # максимальную длину и она корректна
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain

        # Заменяем нашу цепочку, если нашли другую, 
        # которая имеет большую длину и является корректной
        if new_chain:
            self.chain = new_chain
            return True
 	
        return False

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

resolve_conflicts() – это метод который в цикле проходит по всем соседним узлам, скачивает их цепочки и проверяет их, используя метод выше. Если найдена необходимая цепочка, то мы заменяем текущую на эту.

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

@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values = request.get_json()

 	
    nodes = values.get('nodes')
    if nodes is None:
        return "Error: Please supply a valid list of nodes", 400

    for node in nodes:
        blockchain.register_node(node)

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

 	
@app.route('/nodes/resolve', methods=['GET'])
def consensus():
    replaced = blockchain.resolve_conflicts()
 	
    if replaced:
        response = {
            'message': 'Our chain was replaced',
            'new_chain': blockchain.chain
        }
    else:
        response = {
            'message': 'Our chain is authoritative',
            'chain': blockchain.chain
        }

    return jsonify(response), 200

На этом этапе вы можете задействовать любое количество машин, по вашему усмотрению, и реализовать различные узлы в вашей сети. Или же реализовать все то же самое на одной машине, используя разные порты. Я это реализовал вторым способом, используя разные порты. То есть, я зарегистрировал другой узел, уже с имеющимся узлом. Итак, у меня есть два узла: http://localhost:5000 и http://localhost:5001.

После чего я замайнил новые блоки на узел 2, для того чтобы цепочка стала длиннее. Потом, я вызвал GET /nodes/resolve на узел 1, где цепочка была заменена по алгоритму Консенсуса:

И это просто обёртка… Объединитесь с друзьями для того, чтобы затестить свой Блокчейн.

…

Итак, мы с вами написали свой блокчейн. Я надеюсь, что данная статья способствует тому, что вы создадите что-то новое для себя.

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

Другие материалы по теме

Простейший блокчейн своими руками
10 полезных ресурсов по технологии blockchain

Ссылка на оригинальную статью
Перевод: Александр Давыдов

Источник

Содержание

#1. Шаг 1. Определение идеи
#2. Шаг 2. Поиск технического партнера
#3. Шаг 3. Выбор оптимальной платформы
#4. Шаг 4. Разработка каркаса приложения
#5. Шаг 5. Создание пользовательского интерфейса
#6. Шаг 6. Реализация приложения в коде
#7. Шаг 7. Тестирование и проверка
#8. Шаг 8. Запуск и развертывание
#9. Шаг 9. Продвижение проекта
#10. Стоимость блокчейн-приложений

Появились вопросы?

Юрий Мусиенко

Автор статьи

Merehead занимается разработкой веб проектов

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

Шаг 1. Определение идеи

Какие сектора чаще всего используют блокчейн помимо криптовалюты. Источник

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

Технология блокчейн будет полезна в следующих случаях:

Если мобильное приложение будет работать с деньгами пользователей: платежный шлюз, страховой сервис, онлайн-магазин, благотворительность. Блокчейн и смарт-контракты смогут обеспечить честность и надежность сделок, уменьшить транзакционные комиссии и количество посредников.
Если нужно заручиться доверием пользователей. Это важно, если вы создаете блокчейн-приложение на Android и iOS с функцией голосования, например для праймериз, выборов руководства организации или того, куда и как потратить благотворительные средства. Блокчейн способен обеспечить прозрачность и проверяемость таких плебисцитов без раскрытия тайны голосования.
Если нужна автоматизация бизнес-процессов. При должной реализации смарт-контракты могут автоматизировать больше типовых задач, связанных с документооборотом и платежами. Например, смарт-контракты уже сейчас используются для автоматизации прохождения таможни, в сделках с недвижимостью, а также для отслеживания происхождения товаров.
Если нужна максимально надежная система идентификации и / или верификация чего-либо. Например, блокчейн показал свою полезность для идентификации личности, регистрации недвижимости и авторских прав.
Если нужна лучшая защита конфиденциальных данных. Самый простой пример — защита персональных данных пациента при его общении с врачом.

Шаг 2. Поиск технического партнера

После того как вы определитесь с тем, какие именно блокчейн приложения на Android & iOS вы планируете создать, ваш следующий шаг — поиск разработчика. Технический партнер нужен, поскольку создать мобильное приложение на блокчейне посредством шаблонов, как в случае с сайтами на WordPress, не выйдет. Блокчейн требует определенных знаний и навыков, а также стоит на 15-30% дороже.

О том, на что обращать внимание при поиске технического партнера, описано в статье: «Как выбрать компанию-разработчика программного обеспечения».

Шаг 3. Выбор оптимальной платформы

Статистика самых востребованных платформ среди разработчиков Dapps. Источник

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

Вот несколько самых популярных среди разработчиков вариантов:

Ethereum — самый популярный вариант, который позволит разрабатывать блокчейн-приложение и создавать свою собственную экосистему с помощью языка программирования Solidity. Подходит для большинства проектов, делающих ставку на децентрализацию, прозрачность и безопасность.
TRON — бесплатная глобальная финансовая система, позволяющая обмениваться токенами или цифровым контентом простым и экономичным способом. Например, игровыми айтемами в онлайновых играх или фильмами и сериалами в Netflix. Особенность TRON в том, что ее блокчейн позволяет делать такие обмены моментально и с очень низкой комиссией, благодаря чему даже торговые сделки на 1 доллар будут рентабельными
Hyperledger — платформа от Linux Foundation, ориентированная на корпоративный сектор. Позволяет запускать собственные централизованные или гибридные блокчейны с настраиваемыми параметрами доступа. Чтобы создать приложение на Android и iOS на этой платформе, вам понадобится команда разработчиков со знанием языков Go, Java и JavaScript.
IOTA — распределительный реестр с открытым исходным кодом для Интернета вещей, который вместо традиционного блокчейна использует направленный ациклический граф (DAG). Предоставляет такие возможности, как бескомиссионные транзакции, обработка неограниченного количества транзакций за раз, более быстрое время подтверждения. Это обеспечивает более быстрые и безопасные взаимодействия между IoT-устройствами.
R3 Corda — платформа J.P. Morgan для банковского сектора. Ее главная особенность — простая и быстрая интеграция с устаревшими системами (крупные банки, как правило, используют довольно старый софт).
EOS — платформа, нацеленная на решения, которые делают ставку на функции смарт-контрактов, децентрализованный хостинг приложений и децентрализованное хранилище для корпоративного решения, которое полностью устраняет проблемы масштабируемости.

Шаг 4. Разработка каркаса приложения

Пример каркаса низкой (слева) и высокой (справа) точности. Источник

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

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

Разработка каркасов обычно требует два этапа:

Создание каркаса низкой точности. Грубый схематичный набросок, помогающий быстро получить представление о базовой структуре вашего приложения. Такая визуализация проще усваивается большинством людей, нежели представление проекта в виде текста, таблиц и диаграмм.
Создание каркаса высокой точности. В такой схеме аннотированные блоки заменяются изображениями, готовыми статьями (текстами) и ссылками.

Шаг 5. Создание пользовательского интерфейса

Пример готового дизайна интерфейса блокчейн-приложения. Источник

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

Вот что дизайнеры должны сделать на этом этапе:

Определить стилистику. Готовятся несколько наборов изображений (moodboards), на которых представлены экраны приложения с различными цветовыми схемами, шрифтовыми композициями, кнопками и иллюстрациями. Эти изображения отправляются заказчику и / или фокус-группе, которые выбирают из них самый приятный и наиболее соответствующий нише.
Создать концепцию дизайна. Она призвана показать, как будет выглядеть готовое приложение. Если предыдущий этап давал лишь общее направление, то концепция призвана скрестить это направление с наполнением интерфейса (каркасом высокой точности). Обычно для этого делают полное оформление 1-3 экранов приложения, после чего те отправляются на согласование.
Оформить все экраны. Если концепция получила добро, дизайнеры приступают к финализации внешнего вида интерфейса, результатом которой становится полная схематичная структура всех экранов интерфейса. Затем все экраны собираются в интерактивный прототип, который дает максимально приближенный опыт использования приложения без его реализации в коде.
Создать анимацию интерфейса. В ходе этого этапа дизайнеры определяют, как будет выглядеть нажимание на иконки, переход экранов, открытие видео / изображения и т.п. Обычно анимацию делают с помощью Adobe Photoshop или другого инструмента, а затем из этого составляют видеоролики. Видео нужны заказчику, чтобы понять, как анимация будет выглядеть в итоговом варианте, а также разработчикам, которые будут ориентироваться на эти ролики при реализации дизайна и функционала приложения в коде.
Подготовить материалы для разработчиков. После завершения создания внешнего вида интерфейса дизайнеры отправляют разработчикам спрайты, шрифты со всеми иконками, UI Kit с повторяющимися элементами интерфейса и их состояниями, а также все остальные материалы с документацией.

Шаг 6. Реализация приложения в коде

После проектирования UI / UX начинается процесс реализации этого дизайна и бизнес-логики приложения в коде. Обычно это подразумевает реализацию на уровне background (серверной части) и foreground (интерфейс приложения). Данный процесс может выглядеть по-разному в зависимости от нескольких аспектов:

Какой язык и платформу вы выбираете для своего проекта.
Используете вы BaaS или создаете свою собственную цепочку блоков.
Стратегия взаимодействия и транзакций между всеми узлами.
Выбранный механизм консенсуса блокчейна.
Какие SDK API вы используете.

При этом обычно сначала создают минимально жизнеспособный продукт (MVP), на котором проверяют концепцию и получают обратную связь. С этими данными продукт дорабатывается до релизной версии.

Шаг 7. Тестирование и проверка

Тщательное тестирование вашего блокчейн приложения — это одно из обязательных условий разработки блокчейн-приложений, если вы намерены добавить ваш продукт в листинги Google Play Store или Apple App Store. Данные площадки в обязательном порядке требуют, чтобы app было протестировано на основе различных параметров и критериев, не имело ошибок (критических) и хорошо работало в любых сценариях использования. Кроме того, также нужно проверить работоспособность приложения при повышенной нагрузке.

Этим занимаются QA-инженеры, или специалисты.

Шаг 8. Запуск и развертывание

Развертывание — последний этап процесса разработки. Как только продукт будет готов и пройдет все тесты, его можно регистрировать на таких маркетплейсах, как Google Play Store и Apple App Store. Для этого вам нужно:

Зарегистрироваться на Google Play Console и Apple Developer.
Заполнить соответствующую форму добавления приложения в листинг.
Заплатить за регистрацию (25 долларов для Google, 99 долларов — Apple) и согласиться с пользовательским соглашением.

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

Шаг 9. Продвижение проекта

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

Листинги — от 0 до 200 долларов. Мы уже писали, что публикация приложения в Google Play Store и Apple App Store стоит денег, аналогичная ситуация с большинством других магазинов приложений. Однако вместе с этим вы можете добавить свой софт на бесплатные листинги приложений, онлайн-агрегаторы, а также на Instagram, Facebook, Twitter и LinkedIn.
Платная реклама — от 50 до 5000 долларов в месяц. Это реклама с оплатой за клик или просмотр в поисковиках, социальных сетях и веб-сайтах.
Контент-маркетинг — от 500 до 10000 долларов в месяц. Запуск сайта с блогом, который вы будете наполнять релевантным нише контентом для повышения места в поисковой выдаче поисковиков, а также роста узнаваемости и репутации компании. Контентом могут быть обучающие, информационные, новостные и развлекательные статьи, видео, фото.
SMM (англ. social media marketing) — от 500 до 5000 долларов в месяц. Создание постов в Facebook, Instagram, Twitter, LinkedIn и их продвижение внутри площадки, в том числе с помощью инфлюенсеров.
E-mail-рассылка — от 0 до 1000 долларов в месяц. Создание нескольких шаблонов электронных писем с ориентацией на разные подгруппы целевой аудитории. Такие письма могут содержать текст, фото, анимацию, видео.
SEO (Search Engine Optimization) — от 600 до 5000 долларов в месяц. Анализ запросов в выбранной нише, создание SEO-ядра, оптимизация контента и создание ссылочной массы.

Больше на тему маркетинга можно прочесть в статьях:

«Как разработать план маркетинг-стратегии».
«10 успешных цифровых маркетинг-стратегий».
«Как выбрать маркетинговое агентство».

Стоимость блокчейн-приложений

Детально о стоимости блокчейн-разработки с примерами и разбивкой по этапам и процессам описано в статье: «Сколько стоит разработка и внедрение блокчейна». Здесь же мы просто представим таблицу ориентировочной стоимости создания Dapp для Android и iOS в зависимости от сложности и функционала проекта.

Оцените
(108 оценки — 4.3 из 5)

Спасибо!

5 stars
4 stars
3 stars
2 stars
1 star

TorMarket — маркетплейс с гибкой системой фильтрации и удобным кабинетом для поставщиков.

Category: Мобильные приложения 11/08/2022

Как Использовать Блокчейн в Нефтегазовой Отрасли?

В 2018 году BP, Shell, Repsol, Газпром и другие крупные игроки нефтегазовой отрасли запустили пилотные блокчейн-проекты для решения логистических, торговых и финансовых задач. В статье мы рассмотрим эти и другие кейсы, чтобы понять, как новую технологию используют в нефтегазовой отрасли и какие преимущества она дает.

Category: Мобильные приложения 10/27/2022

Безопасность Блокчейн Технологии

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

Category: Мобильные приложения 10/27/2022

Топ-10 Вариантов Использования Корпоративных Блокчейн-Решений

«Вы либо внедрите блокчейн, либо исчезнете», — сказал гендиректор FedEx Corporation Фред Смит на блокчейн-конференции «Consensus 2018». И это не пустые заявления: практически все крупные компании либо рассматривают такую возможность, либо уже внедрили блокчейн в свой бизнес. Сегодня мы рассмотрим 10 примеров использования блокчейна крупными компаниями, которые доказали пользу этой технологии.

Источник

Время на прочтение
9 мин

Количество просмотров 76K

Доброго всем! Мы тут потихоньку начали исследовать новое совсем для нас направление для обучения — блокчейны и нашли то, что оказалось интересным в рамках нашего курса по Python, в том числе. Чем, собственно, и хотим поделиться с вами.

Я могу узнать, когда у меня появился первый Bitcoin, из истории кошелька в моем аккаунте на Coinbase — входящая транзакция в 2012 году в подарок за регистрацию. Bitcoin в то время стоил около 6.50$. Если бы я сохранил те 0.1 BTC, на момент написания статьи это бы уже стоило более 500$. Если кому-то интересно, я продал их, когда Bitcoin стоил 2000$. Так что я получил только 200$ вместо ныне возможных 550$. Не стоило торопиться.

О существовании Bitcoin я знал, но особо не интересовался. Я видел взлеты и падения курса $/BTC. Я видел, как люди говорят, что за ним будущее, а видел статьи о его полной бессмысленности. Но личного мнения у меня не было — просто наблюдал со стороны.
Точно так же я почти не следил за блокчейнами. Но в последнее время мой отец несколько раз упоминал, что на CNBC и Bloomberg, которые он смотрит по утрам, часто рассказывают о блокчейнах, и он понятия не имеет, что это.

И тогда я внезапно понял, что нужно чуть глубже разобраться в этой теме. И начал с “исследования” — прочитал огромное количество статей в интернете, объясняющую их суть. Некоторые были хорошие, некоторые плохие, некоторые глубокие, а некоторые очень поверхностные.

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

Нужно учитывать, что есть большая разница между базовым блокчейном, который я описываю и “профессиональным” блокчейном. Эта цепь не создаст криптовалюту. Блокчейны не требуют производства монет, которые можно продавать и менять на физические деньги.
Блокчейны используются для хранения и подтверждения информации. Монеты побуждают узлы участвовать в валидации, но их наличие не обязательно.

Я пишу пост по нескольким причинам: 1) Чтобы люди, прочитавшие его, смогли узнать больше о блокчейнах; 2) Чтобы я смог понять больше, объяснив код, а не просто написав его.
В этом посте я покажу способ хранения данных блокчейна и генерации начального блока, синхронизацию узла с локальными данными блокчейна, отображение блокчейна (что впоследствии будет использоваться для синхронизации с другими узлами), а затем, майнинг и создание валидных новых блоков. В первом посте не будет никаких других узлов. Никаких кошельков, пиров, важных данных. О них поговорим позднее.

В двух словах

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

На самом высоком уровне, блокчейн — база данных, где каждый, участвующий в блокчейне, может хранить, просматривать, подтверждать и никогда не удалять данные.

На более низком уровне, данные в этих блоках могут быть чем угодно, пока это позволяет конкретный блокчейн. Например, данные в Bitcoin блокчейне — исключительно транзакции Bitcoin между аккаунтами. Ethereum блокчейн позволяет как аналогичные транзакции Ether, так и транзакции, использующиеся для запуска кода.

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

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

Если хотите изучить код, посмотрите ветку part 1 на Github. Смело присылайте мне любые вопросы, комментарии, правки и похвалы (если вы в настроении сделать что-то особо хорошее), или просто пишите в твиттер.

Шаг 1 — Классы и Файлы

Первый шаг — написание класса, обрабатывающего блоки при запуске узлов. Я назову этот класс Block. Честно говоря, много делать не придется. В функции __init__ мы будем верить, что вся необходимая информация уже представлена в словаре. Для производственного блокчейна — это не самое мудрое решение, но подходит в качестве примера, потому что код пишу только я. Также я напишу метод, запаковывающий важную информацию блока в словарь, а после заведу более удобный способ для отображения информации блока при его печати в терминал.

class Block(object):
  def __init__(self, dictionary):
  '''
    We're looking for index, timestamp, data, prev_hash, nonce
  '''
  for k, v in dictionary.items():
    setattr(self, k, v)
  if not hasattr(self, 'hash'): #in creating the first block, needs to be removed in future
    self.hash = self.create_self_hash()

  def __dict__(self):
    info = {}
    info['index'] = str(self.index)
    info['timestamp'] = str(self.timestamp)
    info['prev_hash'] = str(self.prev_hash)
    info['hash'] = str(self.hash)
    info['data'] = str(self.data)
    return info

  def __str__(self):
    return "Block<prev_hash: %s,hash: %s>" % (self.prev_hash, self.hash)

Чтобы создать первый блок, запустим этот простой код:

def create_first_block():
  # index zero and arbitrary previous hash
  block_data = {}
  block_data['index'] = 0
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = 'First block data'
  block_data['prev_hash'] = None
  block = Block(block_data)
  return block

Отлично. Последний вопрос в этой части — где хранить данные в файловой системе. Это необходимо, если мы не хотим потерять локальные данные блока при отключении узла.
Я назову папку с данными ‘chaindata’, в какой-то степени подражая схеме папок Etherium Mist. Каждому блоку теперь присвоен отдельный файл, названный по его индексу. Нужно убедиться, что имена файлов содержат в начале достаточное количество нулей, чтобы блоки перечислялись по порядку.

С учетом кода выше, нужно написать следующее для создание первого блока:

#check if chaindata folder exists.
chaindata_dir = 'chaindata'
if not os.path.exists(chaindata_dir):
  #make chaindata dir
  os.mkdir(chaindata_dir)
  #check if dir is empty from just creation, or empty before
if os.listdir(chaindata_dir) == []:
  #create first block
  first_block = create_first_block()
  first_block.self_save()

Шаг 2 — Синхронизация блокчейна, локально

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

def sync():
  node_blocks = []
  #We're assuming that the folder and at least initial block exists
  chaindata_dir = 'chaindata'
  if os.path.exists(chaindata_dir):
    for filename in os.listdir(chaindata_dir):
      if filename.endswith('.json'): #.DS_Store sometimes screws things up
        filepath = '%s/%s' % (chaindata_dir, filename)
        with open(filepath, 'r') as block_file:
          block_info = json.load(block_file)
          block_object = Block(block_info) #since we can init a Block object with just a dict
          node_blocks.append(block_object)
return node_blocks

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

Шаг 3 — Отображение блокчейна

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

Для этого я использую Flask — у него низкий порог вхождения, и я решил, что он подходит для наших целей.

Ниже представлен код для отображения json блокчейна. Я проигнорирую импорты для экономии места.

node = Flask(__name__)

node_blocks = sync.sync() #inital blocks that are synced

@node.route('/blockchain.json', methods=['GET'])
def blockchain():
  '''
  Shoots back the blockchain, which in our case, is a json list of hashes
  with the block information which is:
  index
  timestamp
  data
  hash
  prev_hash
  '''
  node_blocks = sync.sync() #regrab the nodes if they've changed
  # Convert our blocks into dictionaries
  # so we can send them as json objects later
  python_blocks = []
  for block in node_blocks:
    python_blocks.append(block.__dict__())
  json_blocks = json.dumps(python_blocks)
  return json_blocks

if __name__ == '__main__':
  node.run()

Запустите этот код, зайдите на localhost:3000/blockchain.json и увидите текущий блок.

Шаг 4 — “Майнинг”, также известный как создание блока

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

Сатоши описывает это следующим образом в Bitcoin whitepaper. Учтите, что “timestamp сервер” назван “узлом”.

“Начнем описание нашего решения с timestamp сервера. Его работа заключается в хэшировании блока данных, на который нужно поставить timestamp, и открытой публикации этого хэша… Timestamp показывает, что в данный момент конкретные данные существовали и потому попали в хэш блока. Каждый хэш включает в себя предыдущий timestamp: так выстраивается цепь, где очередное звено укрепляет все предыдущие.”

Скриншот изображения, прикрепленного под описанием:

Основная идея раздела — при необходимости соединить блоки, мы создаем хэш информации о новом блоке, включая время создания блока, хэш предыдущего блока и информацию в самом блоке. Я буду называть всю эту информацию “хедером” блока. Таким образом, мы можем проверить корректность блока, посчитав все хэши перед ним, подтвердив последовательность.

В данном случае хедер, который я создаю, объединяет значения строки в одну огромную строку. Я включил следующие данные:

Индекс, показывающий каким по счету является блок;
Хэш предыдущего блока;
Данные — просто случайные строки. Для bitcoin они называются Merkle root и содержат информацию о транзакциях;
Timestamp майнинга этого блока.

def generate_header(index, prev_hash, data, timestamp):
  return str(index) + prev_hash + data + str(timestamp)

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

Хедер Bitcoin значительно сложнее объединения строк. Он использует хэши данных и времени и завязан на то, как данные расположены в памяти. Но в нашем случае объединения строк достаточно.

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

def calculate_hash(index, prev_hash, data, timestamp, nonce):
  header_string = generate_header(index, prev_hash, data, timestamp, nonce)
  sha = hashlib.sha256()
  sha.update(header_string)
  return sha.hexdigest()

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

node_blocks = sync.sync()

def mine(last_block):
  index = int(last_block.index) + 1
  timestamp = date.datetime.now()
  data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions
  prev_hash = last_block.hash
  block_hash = calculate_hash(index, prev_hash, data, timestamp)

  block_data = {}
  block_data['index'] = int(last_block.index) + 1
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = "I block #%s" % last_block.index
  block_data['prev_hash'] = last_block.hash
  block_data['hash'] = block_hash
  return Block(block_data)

def save_block(block):
  chaindata_dir = 'chaindata'
  filename = '%s/%s.json' % (chaindata_dir, block.index)
  with open(filename, 'w') as block_file:
    print new_block.__dict__()
    json.dump(block.__dict__(), block_file)

if __name__ == '__main__':
  last_block = node_blocks[-1]
  new_block = mine(last_block)
  save_block(new_block)

Готово! Но при таком типе создания блока кто угодно с самым быстрым CPU сможет создавать самые длинные цепи, которые другие узлы посчитают корректными. Нужен способ снизить скорость создания блока и подтверждение до перехода к следующему блоку.

Шаг 5 — Доказательство выполнения работы

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

Способ сделать это — установить требования к структуре хэша блока. Как и в случае с bitcoin, необходимо убедиться, что хэш начинается с определенного количества нулей, перед тем, как перейти к следующему. А для этого нужно добавить в хедер дополнительную информацию — случайно перебираемое число (nonce).

def generate_header(index, prev_hash, data, timestamp, nonce):
  return str(index) + prev_hash + data + str(timestamp) + str(nonce)

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

NUM_ZEROS = 4

def mine(last_block):
  index = int(last_block.index) + 1
  timestamp = date.datetime.now()
  data = "I block #%s" % (int(last_block.index) + 1) #random string for now, not transactions
  prev_hash = last_block.hash
  nonce = 0

  block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce)
  while str(block_hash[0:NUM_ZEROS]) != '0' * NUM_ZEROS:
    nonce += 1
    block_hash = calculate_hash(index, prev_hash, data, timestamp, nonce)
  block_data = {}
  block_data['index'] = int(last_block.index) + 1
  block_data['timestamp'] = date.datetime.now()
  block_data['data'] = "I block #%s" % last_block.index
  block_data['prev_hash'] = last_block.hash
  block_data['hash'] = block_hash
  block_data['nonce'] = nonce
  return Block(block_data)

Отлично. Новый блок содержит валидное значение nonce, поэтому другие узлы могут подтвердить хэш. Мы можем сгенерировать, сохранить и распределить новый блок остальным.

Заключение

На этом все! Пока что. Осталось еще много вопросов и фичей в блокчейнах, которые я не объяснил.

Например, как задействовать другие узлы? Как узлы передают данные, когда включаются в блок? Существуют ли иные способы хранения данных кроме огромных строк данных?
Ответы на эти вопросы можно будет найти в следующих частях этой серии постов, как только я сам найду на них ответы. Пожелания по содержанию можно писать мне в твиттер, в комментарии к посту или через форму обратной связи!

Спасибо моей сестре Саре за уточняющие вопросы о блокчейнах и помощь в редактировании поста!

THE END

Комментарии, вопросы, как всегда, приветствуются и тут, и на дне открытых дверей.

Источник

Что такое блокчейн-приложения

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

Как работает блокчейн

Блокчейн-приложения часто называют децентрализованными. Они основаны на одноранговых децентрализованных сетяхhttps://academy.binance.com/ru/articles/peer-to-peer-networks-explained и имеют уникальные функции, отличные от традиционных приложений. В блокчейне нет центрального органа управления, который играл бы роль посредника между пользователями, обменивающимися данными или деньгами.

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

Обычные и децентрализованные приложения

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

Обзор рынка блокчейн-приложений

Давайте посмотрим на внедрение блокчейн-технологий в цифрах и статистике.

Согласно State of the DAppshttps://www.stateofthedapps.com/stats, на октябрь 2022 года в отрасли насчитывается около 4000 децентрализованных приложений.
В 2018 году объем рынка блокчейна составил около 1,57 миллиарда долларов, тогда как, по данным Dot Com Infowayhttps://www.dotcominfoway.com/blog/growth-and-facts-of-blockchain-technology/#gref, в 2024 году он может превысить 20 миллиардов долларов.
Как показало исследование Grand View Researchhttps://www.grandviewresearch.com/industry-analysis/blockchain-technology-market, объем мирового рынка блокчейн-технологий в 2020 году оценивался в 3,67 миллиарда долларов США. Ожидается, что совокупный годовой темп роста (CAGR) составит 82,4% в период с 2021 по 2028 год.

Тренды блокчейн-приложений

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

Типы блокчейн-приложений

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

Диаграмма с типами блокчейн-приложений

Финансовые блокчейн-приложения

Схема финансовых блокчейн-приложений

DeFi приложения, сокращенно от англ. decentralized finance (децентрализованные финансы) — это инструменты для совершения денежных транзакций. К ним относятся децентрализованные биржи, обменники и другие приложения и блокчейн-платформы, предназначенные для операций с криптовалютой. Самые известные типы DeFi приложений:

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

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

Гейминг и азартные игры. В построенных на блокчейне play-to-earn (p2e)https://learn.bybit.com/ru/crypto/top-nft-games/ играх пользователи могут получать токены с реальной стоимостью во время игры, поэтому гейминг и азартные игры можно классифицировать как часть DeFi.

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

Одна из первых игр, CryptoKitties, была выпущена на платформе Ethereum в конце 2017 года, а уже в июле 2019 года децентрализованные приложения из этой категорий занимали топ-5 мест в рейтинге самых популярных блокчейн-приложений.

Нефинансовые блокчейн-приложения

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

Сервисы для идентификации пользователей становятся все более актуальными с развитием дистанционного оказания услуг, например, онлайн-банкинг. Децентрализованные приложения обеспечивают безопасное и надежное хранение пользовательских данных. Только сам пользователь имеет доступ к своим данным, личная информация надежно зашифровывается, а для анонимности предоставляется уникальный адрес или идентификационный номер. Для финансовых организаций это тоже выгодно, так как благодаря проверке личности повышается прозрачность и честность сделок. Один пользователь не может создать несколько профилей, верифицированных при помощи процесса проверки « Знай своего клиентаhttps://advapay.eu/ru/chto-takoje-znaj-svojego-klienta-kyc/» (англ. Know your customer, KYC).

Сервисы для совместного использование дисков или вычислительной мощности. Автономные хранилища данных и сети связи предоставляют пользователям токены, которые можно обменять или получить в обмен только на пространство на диске или вычислительную мощность для компьютера. Основные преимущества — анонимность, прозрачность и безопасность. SAFE Network была первым сервисом такого типа; она использует токены Safecoin, которые нигде не продаются.

Глобальная децентрализованная сеть для обеспечения безопасности облачного хранилища

Децентрализованные автономные организации (ДАО)

Децентрализованные автономные организации (ДАО) — весьма амбициозные приложения в криптомире. Их цель — создать компании без лидеров. На этапе разработки создается регламент, устанавливающий, как участники могут присоединяться, голосовать или выпускать токены и распределять средства компании. В криптоиндустрии работа ДАО основана на смарт-контрактах, поэтому основная инфраструктура появилась благодаря сети Ethereum.

Важно обратить внимание на то, что ДАО — это не платформа, а система управления. Например, неправильно было бы назвать криптобиржу Uniswap ДАО, но ее децентрализованная система управления — это ДАО. Автоматизация управления помогает избавиться от штата сотрудников, юристов и бухгалтеров, а также свести к минимуму человеческий фактор и коррупцию.

Uniswap Governance — это ДАО

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

Топ-3 блокчейн-приложения

Согласно данным DappRadarhttps://dappradar.com/rankings, самые популярные по количеству пользователей приложения относятся к игровому сектору, но ещё есть DeFi приложения и маркетплейсы, которые вошли в топ в 2022 году. Давайте рассмотрим их особенности.

Alien Worlds

Alien Worldshttps://alienworlds.io/ — это метавселенная NFT, построенная на блокчейне WAX. Пользователи могут взаимодействовать с невзаимозаменяемыми коллекционными предметами и торговать внутриигровыми картами. Платформа предлагает стейкинг — получение вознаграждений за размещение средств на блокчейн-кошельке в течение определенного времени. Также у Alien Worlds есть уникальные децентрализованные автономные организации, в которые пользователи могут вступить.

Скриншот NFT метавселенной Alien Worlds с графиками активности пользователей

PancakeSwap

PancakeSwaphttps://pancakeswap.finance/ — децентрализованная биржа, основанная на Binance Smart Chain (BSC). Она была запущена блокчейн-системой Binance в сентябре 2020 года. На платформе пользователи могут торговать, зарабатывать и выигрывать криптовалюту. Средства биржи составляют более 4,1 миллиарда долларов, и она регулярно упоминается в новостях.

Безопасная, быстрая и удобная конвертация токенов

Splinterlands

Карточная игра Splinterlandshttps://splinterlands.com/ была запущена 25 марта 2021 года и быстро набрала более 185 тысяч пользователей. В игре можно получить реальную прибыль, используя уникальные внутриигровые активы, которыми можно торговать и обмениваться. Пользователи собирают колоды карт и участвуют в сражениях или конвертируют карты в криптовалюту.

Карточная игра, основанная на NFT токенах

Больше последних новостей отрасли вы можете найти в отчете DappRadar Blockchain Industry Reporthttps://dappradar.com/blog/dappradar-blockchain-industry-report-august-2022 за август 2022 года.

самые популярные приложения Dappradar Cамые популярные приложения Dappradar

Преимущества блокчейн-приложений

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

Прозрачность

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

Безопасность

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

Снижение затрат

Приложение на блокчейне помогает упростить бизнес-процессы за счет устранения посредников. Отличным примером являются одноранговые (P2P) транзакции — переводы, которые пользователи совершают непосредственно друг другу через платежные сервисы. В итоге, стоимость предоставления услуг снижается, так как бизнес использует меньше ресурсов и не привлекает сторонние компании.

Отсутствие цензуры

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

Что нужно учитывать при разработке блокчейн-приложений

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

Лучше начать с выбора блокчейн-сети, которая поддерживает децентрализованные приложения, и сравнить преимущества и недостатки сетей. Есть 4 основных фактора, выбор которых нужно тщательно продумать:

Блокчейн. Проанализируйте популярность и уровень доверия к интересующим блокчейн-сетям. Например, Ethereum — самый известный блокчейн, а GoChain и OST практически не изучены.
Операционная система. Выберите тип приложения — веб-, мобильное или десктопное — и операционную систему, с которой вы хотите работать, например, iOS или Android, Mac или Windows, или все вместе.
Модель монетизации. С продуманной моделью монетизации ваше приложение будет приносить прибыль. Она может включать продажу активов, изначально введенных в систему, комиссии за транзакции или рекламу.
Разработчики. ИТ-специалисты отвечают за то, как ваше блокчейн-приложение работает, поэтому вам нужно найти профессионалов, которые могут написать код для смарт-контрактов на высокоуровневом языке программирования.

Технологии для разработки блокчейн-приложений

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

Как создать блокчейн-приложение за 5 шагов

Разработка блокчейн-приложения состоит из нескольких обязательных этапов:

Шаг 1: Проанализируйте проект. Проанализируйте рынок и оцените проект, затем определите основную функциональность и зафиксируйте бюджет и сроки.

Шаг 2: Создайте дизайн. Найдите референсы, определите личные визуальные предпочтения и разработайте дизайн вместе с командой UI/UX дизайнеров.

Шаг 3: Разработайте приложение. Продумайте основные функции вашего приложения, логику работы, взаимодействие с пользователями и внутренние сервисы. Согласуйте все свои идеи с командой разработчиков и создайте продукт.

Шаг 4: Протестируйте приложение. Тестовый запуск помогает проверить все функции приложения и избежать ошибок в его дальнейшей работе.

Шаг 5: Запустите приложение и получите обратную связь. Запустите приложение и соберите отзывы от первых пользователей. Это поможет вам найти новые идеи о том, как улучшить ваше блокчейн-приложения.

Сколько стоит создание блокчейн-приложение

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

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

Стадия	Оценка в часах	Оценка в неделях	Приблизительная стоимость
Анализ бизнес логики проекта	40 часов	1 неделя	50 000 руб.
UI/UX дизайн	211 часов	7 недель	598 000 руб.
Стадия разработки приложения	1305 часов	14 недель	4 036 500 руб.
Тестирование	630 часов	Параллельно разработке	777 000 руб.
Проектный менеджмент	На протяжении всего проекта	На протяжении всего проекта	366 800 руб.

Итого, разработка блокчейн-приложений обойдется примерно в 5 733 500 рублей.

Для получения дополнительной информации и индивидуального предложения — свяжитесь с нами.

Резюмируем

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

Если у вас возникнут вопросы, можете обратиться за консультацией к экспертам Purrweb. Мы будем рады помочь вашей идее воплотиться в жизнь. Заполните форму, и мы свяжемся с вами.

Источник

#статьи

17 авг 2022
13

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

Иллюстрация: Merry Mary для Skillbox Media

Пишет о программировании, в свободное время создаёт игры. Мечтает открыть свою студию и выпускать ламповые RPG.

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

Разбираемся, что же такое блокчейн, и пишем приложение с его использованием.

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

Хеширование — это преобразование данных произвольной длины в битовую строку фиксированной длины. То есть мы можем взять любой текст, например книгу «451 градус по Фаренгейту», а потом зашифровать его с помощью специального алгоритма.

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


6de4c03655fdc3e982e3bfc4f055dae5064547e8b78ef951b80c94b657a5c684

Вряд ли вы узнаете, что здесь зашифровано.

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


efdc5e0108e3906fea8c93efb1d9616b7a26aa26549c5d47a1b6c3fda8199ac9

И опять вы вряд ли узнаете, что здесь зашифровано.

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

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

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

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

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

Рассмотрим это на примере блокнота. Каждая запись в нём будет восприниматься как отдельный блок.

Допустим, есть вот такая первая запись:


Привет, это первая заметка!

Её хеш выглядит так:


7cb70ea12f13042dbfbbf492c20e943b2c62a1007a9921e36f5479f6aa748bc9

Вторая запись содержит в себе саму запись, а также хеш первой записи. То есть:


7cb70ea12f13042dbfbbf492c20e943b2c62a1007a9921e36f5479f6aa748bc9_разделитель_Привет, это вторая запись!

В таком виде заметка хешируется:


8af30f625141cd685dd3ad40f32b0046b562e4efd9746f8225f5a56543a0e50a

И этот хеш становится частью третьей записи.

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

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

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

Эта мера используется, например, в криптовалюте BitCoin. И если кто-то захочет её у вас украсть, ему придётся одновременно заменить блоки на всех компьютерах.

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

Есть и другие варианты:

В блокчейне можно хранить ставки — тогда ни букмекер, ни игрок не смогут обмануть друг друга.
С помощью блокчейна можно проводить выборы — что исключит возможность фальсификации результатов.
Можно заменить нотариуса блокчейном — и заверять документы без него.

Это далеко не весь список.

Не стоит думать, что такая система надёжна на 100%. Возможны ошибки в самом программном обеспечении, которые позволят воровать данные до того, как они будут захешированы.

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

Начнём с создания класса, который представляет собой блок. Назовём его Note.

В своей работе он будет использовать преобразование строки в байты и обратно, а также шифрование, поэтому нужно подключить соответствующие пространства имён:


using System.Text;
using System.Security.Cryptography;

Теперь можно приступать к работе над самим классом:


///<Summary>Заметка для блокнота, который работает на блокчейне</Summary>
class Note
{
    public static string Splitter = "_splitter_";
    private string text;
    private byte[] hash;
 
    public Note(string text)
    {
        this.text = text;
        this.hash = ComputeHash(text);
    }
 
    private byte[] ComputeHash(string text)
    {
        SHA256 sha = SHA256.Create(); //Создаём объект, который будет вычислять хеш
        byte[] textBytes = Encoding.Default.GetBytes(text); //Преобразуем текст заметки в байты
 
        return sha.ComputeHash(textBytes); //Возвращаем хеш
    }
 
    ///<Summary>Полный текст заметки</Summary>
    public string Text { get { return this.text; } }
 
    ///<Summary>Текст заметки без хеша прошлого блока</Summary>
    public string ClearText
    {
        get
        {
            return this.text.Remove(0, this.text.IndexOf(Note.Splitter) + Note.Splitter.Length);
        }
    }
 
    ///<Summary>Хеш прошлого блока</Summary>
    public string PreviousHash
    {
        get
        {
            return this.text.Remove(this.text.IndexOf(Note.Splitter));
        }
    }
 
    ///<Summary>Хеш текущего блока в виде строки</Summary>
    public string HashString
    {
        get
        {
            //При каждом получении текущего хеша нужно считать его заново
            //Так мы будем уверены, что он актуален
            var hash = ComputeHash(this.text); 
            return Encoding.Default.GetString(hash);
        }
    }
 
    ///<Summary>Хеш в виде байтов</Summary>
    public byte[] Hash { get { return this.hash; } }
 
}

Остаётся только написать программу, которая будет использовать эти блоки. Первым делом нужно создать список блоков:


List<Note> notes = new List<Note>(); //Список блоков
 
notes.Add(new Note "start" + Note.Splitter + "First note")); //Добавляем первую заметку

Потом — реализовать метод добавления новых блоков.


static void AddNote(string text, List<Note> notes)
{
    notes.Add(new Note(notes[notes.Count - 1].HashString + Note.Splitter + text));
}

Когда пользователь вводит текст для новой заметки, он передаётся в метод AddNote().Там создаётся новый блок, который содержит текст вида


Хеш предыдущего блока_разделитель_текст заметки

Созданный блок тут же добавляется в список:

Скриншот: Skillbox Media

После того как будет создано несколько заметок, можно проверить список:

Скриншот: Skillbox Media

Здесь отображается только текст заметок, но, если посмотреть на полную информацию о них, можно увидеть, что они содержат в себе хеш прошлого блока:

Хеш выглядит немного иначе, потому что конвертируется сразу в строку, а не в шестнадцатеричное число
Скриншот: Skillbox Media

Просматривать всё это вручную, чтобы проверить достоверность данных, нет смысла, потому что блоков может быть очень много. Вместо этого напишем метод валидации:


///<summary>Проверка подлинности блоков</summary>
static void ValidateNotes(List<Note> notes)
{
    for(int i = 0; i < notes.Count; i++)
    {
        if(i == 0) //Не проверять первый блок
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("0 - Valid");
        }
        else
        {
            Console.ForegroundColor = ConsoleColor.White;
            
            //Проверяем, соответствует ли хеш, записанный в текущий блок, хешу прошлого блока
            if(@notes[i].PreviousHash == @notes[i - 1].HashString) 
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine(i + " - Valid");
            }
            else
            {
                Console.WriteLine($"nn | {notes[i].PreviousHash} | {notes[i - 1].HashString} | nn");
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(i + " - Changed");
            }
        }
    }
 
    Console.WriteLine("n");
}

Теперь можно проверить, всё ли в порядке с заметками, которые мы сохранили:

Скриншот: Skillbox Media

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

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

Если же вы хотите изучить тему глубже, советую почитать статью на Habr. Там же есть ссылка на учебник по защите информации.

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

Участвовать

Источник

Нажмите кнопку «Create a new account». Проверьте, что выбрали сеть Testnet в левом нижнем углу. Это позволит получить тестовые токены WAVES для экспериментов с транзакциями!

Такая страничка станет доступна после создания аккаунта. Обратите внимание, что у аккаунта есть четыре поля: адрес и публичный ключ, которые позволяют идентифицировать его в сети, а также приватный ключ и seed-фраза, выступающие в роли пароля. Раскрывать приватный ключ и seed-фразу нельзя! Поэтому символы скрыты звездочками.

В верхней части окна Waves Keeper отображается баланс. Сейчас там достаточно угнетающе горят нули. Давайте пополним баланс аккаунта с помощью Waves Faucet, который позволяет «начеканить» тестовых монет. Кликните на «Transactions» и перейдите в Waves Explorer:

Этот инструмент отображает данные блокчейна в удобной форме. На странице отображена вся информация по нашему аккаунту. Пока тут ничего интересного: ни транзакций, ни баланса. Позже здесь можно будет легко отслеживать изменения. Это может сделать каждый с помощью Waves Explorer!

В левом нижнем углу перейдите на страницу Faucet:

Вбейте адрес своего аккаунта и докажите, что вы не робот. После этого получите 10 тестовых WAVES на счет:

Теперь у нас есть стартовый капитал для экспериментов! Приступим к самому интересному и научим наше приложение общаться с блокчейном. В наш уже созданный аккаунт можно сохранять данные, используя его Data State. Пока он пустой:

С помощью транзакций мы можем менять данные аккаунта. Это несложно, ведь для таких задач у Waves Keeper есть API: https://docs.waves.exchange/en/waves-keeper/waves-keeper-api!

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

Транзакция – факт свершения какого-то события. Например, перевод денег – это транзакция. Выпуск новой валюты – транзакция. Выгрузка смарт-контракта – транзакция. И просто запись данных – тоже транзакция! Для каждого из типов событий есть свой тип транзакций.

На картинке выше нас интересует тип 12 – Data Transaction. Наша цель – хранить данные.

Отправка сертификатов в блокчейн

Используем Waves Keeper, чтобы отправить транзакцию.

Пример транзакции в Waves Keeper:

https://gist.github.com/vlzhr/4c2015f1c614b656826a3622d786c084

Создаем обработчик клика по кнопке «Добавить диплом», чтобы в транзакции хранились данные о документе.

Функция sendData:

https://gist.github.com/vlzhr/448a0a26072960a80ef60ce4d4151ac6

Теперь при нажатии на кнопку «send!» пользователь добавляет сертификат в блокчейн:

После ввода пароля от расширения отобразится информация по отправляемой транзакции и предложение подписать ее:

Какую информацию о транзакции мы видим? Прежде всего – тип Data Transaction, который означает, что цель транзакции – отправить данные в блокчейн. Мы видим и сами данные: под ключом «1» пользователь сохраняет имя владельца диплома с этим номером – «Sasha Ivanov». Также видим уникальный идентификатор транзакции и комиссию за отправку транзакции в блокчейн.

Транзакция отправлена! Это значит, как минимум, три вещи:

Баланс аккаунта уменьшился, так как 0.001 WAVES ушли на оплату комиссии.

2. На странице аккаунта в Waves Explorer в списке транзакций добавилась одна Data Transaction.

3. Во вкладке Data появился сертификат. Теперь в блокчейне зафиксирован факт владения Сашей Ивановым сертификатом номер 1. Никто не сможет скрыть или изменить эту информацию.

Верификация подлинности сертификатов

Мы разработали приложение, которое позволяет владельцу мероприятия выпускать сертификаты. Waves Explorer отображает сертификаты в блокчейне.

Тем не менее удобнее проверять подлинность диплома через отдельную форму, без необходимости разбираться в Waves Explorer. Сделаем для этой формы дополнительную страницу!

верстка check.html:

https://gist.github.com/vlzhr/e7e7c849980f19e49fae84a20b1ddb0c

Простая верстка позволяет сделать простой интерфейс, который поможет любому верифицировать подлинность сертификата и, при желании, убедиться в ней окончательно в Waves Explorer:

Осталось сделать так, чтобы кнопка «check cerificado!» работала. Добавим хандлер checkData():

Функция checkData:

https://gist.github.com/vlzhr/b2b455a4de8e19d44ccff03b90478dfe

Основной момент – отправка GET-запроса к API блокчейна: https://testnodes.wavesnodes.com/addresses/data/3N6EmqqQ1pZderX8sNMrfVuEo85ocPoqs2M.

Обращение к данному методу API позволяет получить набор данных, которые лежат в стейте аккаунта, к тому самому, что мы видели в Explorer во вкладке Data. Набор доступных методов API блокчейна Waves можно изучить на странице. С помощью доступного функционала можно, например, добавлять транзакции, читать данные и получать информацию по токенам.

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

Задача со звездочкой для удобства пользователей

Итак, наше приложение теперь имеет две страницы: добавления и верификации сертификатов! Последний пункт, который стоит реализовать – возможность делиться ссылкой на проверку своего сертификата.

Функционал шеринга сертификата:

https://gist.github.com/vlzhr/8fc5394215b14e5b599c65edf1bf4dfc

Ссылку на проверку сертификата можно отправлять так, чтобы проверяющему не было нужно заполнять форму. Ссылки вида “URL/check.html?2 VladimirZhuravlev” достаточно, чтобы форма автоматически заполнилась данными 2 Vladimir Zhuravlev.

Заключение

За достаточно короткое время мы разработали полноценное веб-приложение Certificado, разобрались в том, что блокчейн – это удобный способ хранения данных, а Waves Keeper и Waves Explorer – инструменты работы с ним, которые нужно интегрировать в свое приложение.

Используя блокчейн вместо обычного централизованного хранилища данных, можно добавить приложению уникальный функционал и повысить его ценность для клиентов. В экосистеме Waves есть множество инструментов, упрощающих процесс разработки. Помимо разобранных нами Keeper и Explorer, существуют Waves Signer, клиентские библиотеки для разных языков программирования и собственный язык смарт-контрактов Ride.

Разрабатывайте приложения на блокчейне Waves, присоединяйтесь к сообществу разработчиков и задавайте интересующие вопросы в чате в Телеграме.

Присоединяйтесь к Waves Community

Читайте Waves News channel

Смотрите Waves Youtube

Подписывайтесь на Waves Twitter, Waves Subreddit

Источник

Как написать свое первое приложение¶

Примечание

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

Также стоит отметить, что это руководство является введением в приложения Fabric
и использует смарт-контракты и приложения в простой форме.
Для более глубокого изучения приложений Fabric и смарт-контрактов, см.
наш раздел:
Разработка приложений или
Руководство: коммерческие ценные бумаги.

В этом руководстве мы изложим введение в то, как приложения Fabric взаимодействуют
с развернутыми блокчейн-сетями. В этом руководстве используются примеры программ, созданные
при помощи Fabric SDK (наборов средств разработки), подробно описанных в Приложения –
для того, чтобы вызывать смарт-контракты для запроса и обновления реестра посредством
интерфейса смарт-контракта (API), подробно описанного в Исполнение смарт-контрактов.
Мы используем также образцы программ и развернутый удостоверяющий центр для создания
сертификатов X.509, которые потребубися приложению для взаимодействия с приватным блокчейном.

О FabCar

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

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

Сам смарт-контракт, реализующий транзакции взаимодействия с реестром.

Для этого пройдем три принципиально важных этапа:

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

2. Изучение образца смарт-контракта.
Мы исследуем образец смарт-контракта FabCar, чтобы понять транзакции внутри него, и
как они используются приложением для запроса и обновления реестра.

3. Организовать взаимодействие со смарт-контрактом при помощи приложения.
Наше приложение будет использовать смарт-контракт FabCar для опроса и обновления принадлежностей машины в реестре.
Мы погрузимся в программный код приложений и транзакций, которые создаются приложениями, включая опрос машины, опрос нескольких
машин и создание новой машины.

После того, как вы изучите руководство, вы будете иметь основы представлений о том,
как взаимодействует приложения Fabric и смарт-контракты — для того, чтобы управлять данными
в распределенном реестре блокчейн-сети.

Предисловие:¶

Вдобавок к стандарным требованиям Необходимые инструменты для Fabric, в этом руководстве также испольуется Hyperledger Fabric SDK для Node.js.
Ознакомьтесь с Node.js SDK README в котором содержится актуальный набор требований для начала работы.

Если вы используете macOS, следует предпринять следующие шаги:
1. Установите Homebrew.
2. Сверьтесь со списком требований к Node SDK prerequisites чтобы знать, Node какого уровня установить.
3. Запустите brew install node чтобы загрузить последнюю версию узла или выберите конкретную версию, как пример: brew install node@10 в зависимости от того, что требуется.
4. Запустите npm install.
Если вы в среде Windows, можете установить windows-build-tools с npm, который установит все требуемые компиляторы и инструменты при запуске следующей команды:
```
npm install --global windows-build-tools
```
Если вы в среде Linux, вам нужно установить Python v2.7, make, и набор компиляторов C/C++, такой как GCC. Затем можете запустить следующую команду, чтобы установить оставшиеся инструменты:
```
sudo apt install build-essentials
```

Настройка сети блокчейн¶

Если вы уже проходили шаги в руководстве Использование примера сети Fabric и подняли сеть,
тогда данное руководство остановит вашу ранее запущенную сеть, прежде чем запустить новую.

Запуск сети¶

Примечание

это руководство показывает смарт-контракт на примере JavaScript-версии, но репозиторий fabric-samples
содержит также версиии на Go, Java и TypeScript. Для изучения
Go, Java или TypeScript — версий, смените аргумент javascript
для ./startFabric.sh ниже на go, java или typescript
и следуйте инструкциям на терминале.

Проследуйте в поддиректорию fabcar в вашей локальной копии репозитория
fabric-samples.

Запустите скриптом startFabric.sh свою сеть.

./startFabric.sh javascript

Эта команда развернет тестовую сеть Fabric с двумя одноранговыми узлами и службой упорядочения.
Вместо использования инструмента cryptogen tool, мы запустим тестовую сеть
при помощи удостоверяющих центров. Мы используем один из УЦ для того, чтобы создать
сертификаты и ключи, которые пригодятся нашим приложениям на следующем этапе. Скрипт startFabric.sh
также развернет и инициализирует JavaScript-версию смарт-контракта FabCar
на канале mychannel, и затем вызовет смарт-контракт для внесения начальных данных в реестр.

Образец приложения¶

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

Golang
Java
JavaScript
Typescript

В этом руководстве мы разберем образец, написанный на javascript для nodejs.

Из директории fabric-samples/fabcar перейдите в папку
javascript.

Эта директория содержит образцы программ, разработанные при помощи Fabric
SDK для Node.js. Запустите следующую команду для установки зависимостей приложения.
Завершение займет около минуты:

Этот процесс устанавливает ключевые зависимости приложения, определенные в
package.json. Важнейшим из них является класс fabric-network;
при его помощи приложение может использовать идентификаторы, кошельки и шлюзы, чтобы
соединяться с каналами, записывать транзакции и ожидать уведомления. В этом
руководстве также используется класс fabric-ca-client, чтобы удостоверять пользователей
при помощи соответствующих УЦ, создавая для них действующие идентификаторы, которые впоследствии
будут использоваться методами классов fabric-network.

По завершении«npm install«, всё будет готово для запуска приложения.
Давайте посмотрим на файлы приложения JavaScript, которые мы будем использовать:

И вы должны видеть следующее:

enrollAdmin.js  node_modules       package.json  registerUser.js
invoke.js       package-lock.json  query.js      wallet

Для других языков программирования также есть файлы, например в директории
fabcar/java. Можете ознакомиться с ними после того, как изучите пример на
JavaScript – принципы те же.

Регистрация пользователя-администратора¶

Примечание

Последующие два раздела описывают общение с удостоверяющим центром.
Может оказаться полезным наблюдать за потоком журналов УЦ при запуске
программы. Для этого откройте новую терминальную оболочку и запустите:
docker logs -f ca_org1.

Как только мы создали сеть, администратор, буквально admin —
был создан как регистратор для УЦ. Первым нашим шагом будет создание секретного
ключа, открытого ключа и сертификата X.509 для admin, используя программу enroll.js.
Этот процесс использует Запрос на подпись сертификата (CSR) — секретный и открытый ключи сначала
создаются локально, затем открытый ключ посылается в УЦ, который в ответ возвращает
зашифрованный сертификат для использования в приложении. Эти сведения затем хранятся в кошельке,
позволяя нам выполнять роль администратора для УЦ.

Давайте зарегистрируем пользователя admin:

Эта команда сохраняет сведения об адинистраторе УЦ в директории wallet.
Сертификат и секретный ключ можно увиеть в файле wallet/admin.id.

Регистрация пользователя приложения¶

Наш admin работал с УЦ. Теперь, когда удостоверяющие сведения об администраторе
содержатся в кошельке, мы можем создать пользователя приложения, которого в свою очередь
используем для общения с блокчейном. Запустите следующую команду для регистрации и входа
нового пользователя с именем appUser:

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

Запрос к реестру¶

Каждый одноранговый узел в сети блокчейн хранит копию реестра.
Приложение может просматривать последние данные из реестра, производя вызов смарт-контракта
«только на чтение» для своих узлов, который называем «запросом».

В упрощенном виде запрос работает так:

Наиболее распространенным видом запроса является запрос текущего значения данных в реестре
— его «глобальное состояние» — world state.
Глобальное состояние представлено множеством пар ключ-значение, и приложения могут запрашивать созданные
одному или нескольким значениям ключей. Более того, можно использовать сложные запросы
к данным реестра, если вы используете CouchDB как базу данных состояний и моделируете свои данные в JSON.
Это может быть очень полезно, если вы ищете все записи, которые ставят определенные
ключевые слова в соответствие определенным значениям, например, при поиске всех машин одного владельца.

Сначала давайте запустим нашу программу query.js чтобы она сообщила список всех машин в реестре.
Эта программа использует второй наш идентификатор – appUser – чтобы читать реестр.

Результат действия программы должен выглядеть так:

Wallet path: ...fabric-samples/fabcar/javascript/wallet
Transaction has been evaluated, result is:
[{"Key":"CAR0","Record":{"color":"blue","docType":"car","make":"Toyota","model":"Prius","owner":"Tomoko"}},
{"Key":"CAR1","Record":{"color":"red","docType":"car","make":"Ford","model":"Mustang","owner":"Brad"}},
{"Key":"CAR2","Record":{"color":"green","docType":"car","make":"Hyundai","model":"Tucson","owner":"Jin Soo"}},
{"Key":"CAR3","Record":{"color":"yellow","docType":"car","make":"Volkswagen","model":"Passat","owner":"Max"}},
{"Key":"CAR4","Record":{"color":"black","docType":"car","make":"Tesla","model":"S","owner":"Adriana"}},
{"Key":"CAR5","Record":{"color":"purple","docType":"car","make":"Peugeot","model":"205","owner":"Michel"}},
{"Key":"CAR6","Record":{"color":"white","docType":"car","make":"Chery","model":"S22L","owner":"Aarav"}},
{"Key":"CAR7","Record":{"color":"violet","docType":"car","make":"Fiat","model":"Punto","owner":"Pari"}},
{"Key":"CAR8","Record":{"color":"indigo","docType":"car","make":"Tata","model":"Nano","owner":"Valeria"}},
{"Key":"CAR9","Record":{"color":"brown","docType":"car","make":"Holden","model":"Barina","owner":"Shotaro"}}]

Давайте изучим внимательнее, как программа query.js использует программный интерфейс
Fabric Node SDK чтобы
взаимодействовать с нашей сетью Fabric. Используйте редактор (например, atom или visual studio) и откройте

query.js.

Это приложение начинается с рассмотрения двух ключевых классов из
модуля fabric-network; Wallets и Gateway. Эти классы
будут использованы для нахождения идентификатора appUser в кошельке, и использования его
для соединенния с сетью:

const { Gateway, Wallets } = require('fabric-network');

Сначала программа использует класс Wallet, чтобы извлечь нашего пользователя из файловой системы.

const identity = await wallet.get('appUser');

Как только программа получила идентификатор, она использует класс Gateway для соединения с сетью.

const gateway = new Gateway();
await gateway.connect(ccpPath, { wallet, identity: 'appUser', discovery: { enabled: true, asLocalhost: true } });

ccpPath описывает путь к профилю соединения, который будет использовать наше приложение для соединения с нашей сетью.
Профиль соединения был загружен из директории fabric-samples/test-network и размечен как файл JSON:

const ccpPath = path.resolve(__dirname, '..', '..', 'test-network','organizations','peerOrganizations','org1.example.com', 'connection-org1.json');

Если вы захотите узнать подробнее о структуре профиля соединения,
и как он определяет сеть, смотрите в разделе the connection profile.

Сеть может подразделяться на множество каналов, и следующая важная строчка кода соединяет приложение
с конкретным каналом в сети,«mychannel«, в котором был развернут наш смарт-контракт:

const network = await gateway.getNetwork('mychannel');

В рамках этого канала нам доступен смарт-контракт FabCar для взаимодействия с реестром:

const contract = network.getContract('fabcar');

Внутри FabCar много разных транзакций, и наше приложение поначалу
использует транзакцию«queryAllCars«, чтобы извлечь глобальное состояние реестра:

const result = await contract.evaluateTransaction('queryAllCars');

В свою очередь метод evaluateTransaction представляет одну из простейших транзакций
смарт-контракта в сети. Он просто посылает запрос на узел, определенный в профиле соединения, и узел
этот запрос оценивает. Смарт-контракт опрашивает все машины на принадлежащей узлу копии реестра
и возвращает результат приложению. Эта транзакция не изменяет реестр.

Смарт-контракт FabCar¶

Смарт-контракт FabCar есть на следующих языках программирования:

Golang
Java
JavaScript
Typescript

Рассмотрим транзакции в смарт-контракте FabCar, написанном на JavaScript. Откройте
новый терминал и найдите JavaScript-версию смарт-контракта FabCar
в репозитории fabric-samples:

cd fabric-samples/chaincode/fabcar/javascript/lib

Откройте файл fabcar.js в текстовом редакторе.

Вот как определен наш смарт-контракт через класс Contract :

class FabCar extends Contract {...

Внутри структуры этого класса, видно, что у нас определены следующие транзакции:: initLedger, queryCar, queryAllCars,

createCar, и changeCarOwner. К примеру:

async queryCar(ctx, carNumber) {...}
async queryAllCars(ctx) {...}

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

async queryAllCars(ctx) {

  const startKey = '';
  const endKey = '';

  const iterator = await ctx.stub.getStateByRange(startKey, endKey);

Эти строчки кода показывают, как извлечь информацию о всех машинах из реестра, по
диапазону значений ключа: getStateByRange. Если задать startKey и endKey пустыми,
это будет проинтерпретировано, как задание всех ключей от начала и до конца.
Следующим примером, если задать startKey = 'CAR0', endKey = 'CAR999' , тогда getStateByRange
извлечет машины со значениями ключа CAR0 (включительно) and CAR999 (не включая) в алфавитном порядке.
Остаток кода пробегает по результатам запроса и пакует их в JSON для использования приложением.

Ниже приведено представление того, как приложение будет вызывать разные транзакции
смарт-контракта. Каждая транзакция использует широкий набор интерфейсов, таких как
getStateByRange для взаимодействия с реестром. Ознакомиться с интерфейсами подробнее можно
в <https://hyperledger.github.io/fabric-chaincode-node/>`_.

Вот пример транзакции«queryAllCars« и транзакции createCar.
Чуть позже в руководстве мы используем их для изменения реестра и добавления нового
блока в блокчейн.

Но сначала вернемся к программе query и изменим
запрос evaluateTransaction на CAR4. Программа query теперь
будет выглядеть так:

const result = await contract.evaluateTransaction('queryCar', 'CAR4');

Сохраните программу и откройте директорию«fabcar/javascript«.
Теперь снова запустите программу«query«:

Вы должны увидеть следующее:

Wallet path: ...fabric-samples/fabcar/javascript/wallet
Transaction has been evaluated, result is:
{"color":"black","docType":"car","make":"Tesla","model":"S","owner":"Adriana"}

Если вернуться назад и посмотреть на результат транзакции
queryAllCars, можно увидеть, что CAR4 это принадлежащая Адриане (Adriana) черная Tesla model S,
что и соответствует результату выше.

Мы можем использовать транзакцию«queryCar«, чтобы сделать запрос о любой машине, используя
значение ее ключа (например, CAR0) и получить всю информацию об этой машине (модель, владелец, марка, и т.д.).

Прекрасно. Теперь вы умеете составлять транзакции простых запросов в смарт-контракте и познакомились
с несколькими параметрами программы query.

Наступила пора менять реестр…

Обновление реестра¶

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

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

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

Наше первое изменение в реестр создаст новую машину.
У нас есть отдельная программа invoke.js, которую мы используем для внесения изменений в реестр.
Точно так же, как и с запросами, откройте программу в текстовом редакторе и посмотрите на участок кода, в котором
мы сконструировали нашу транзакцию и послали ее в сеть:

await contract.submitTransaction('createCar', 'CAR12', 'Honda', 'Accord', 'Black', 'Tom');

Убедитесь, как приложение вызывает транзакцию смарт-контракта createCar, чтобы
создать черную Honda Accord, принадлежащую Тому. Мы написали CAR12 как ключ
лишь для того, чтобы показать, что последовательные ключи нам здесь не обязательны.

Сохраните и запустите программу:

Если вызов состоялся успешно, вы увидите ровно следующее:

Wallet path: ...fabric-samples/fabcar/javascript/wallet
Transaction has been submitted

Обратите внимание, как приложение invoke провзаимодействовало с сетью, используя
интерфейс submitTransaction, а не evaluateTransaction.

await contract.submitTransaction('createCar', 'CAR12', 'Honda', 'Accord', 'Black', 'Tom');

submitTransaction гораздо более сложен, чем evaluateTransaction.
Не ограничиваясь взаимодействием с одним узлом, SDK пошлет предложение
«submitTransaction«в каждый узел требуемой организации в сети.
Каждый из этих узлов исполнит требуемый смарт-контракт при помощи этого предложения
и создаст и подпишет ответ на транзакцию и вернет его в SDK.
SDK собирает все подписанные ответы на транзакцию в одну транзакцию, которую посылает затем
на узел упорядочения. Узел упорядочения собирает и выстраивает в последовательность транзакции
от каждого приложения в блок транзакций. Затем узел упорядочения рассылает эти блоки всем
узлам в сети, в которых эти транзакции валидируются и записываются. И, наконец, SDK получает от него
уведомление, и контроль возвращается к приложению.

Примечание

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

submitTransaction делает это всё для приложения! Тот процесс, посредством которого
приложение, смарт-контракт, узлы и служба упорядочения сотрудничают для того, чтобы
сохранить реестр одинаковым для всей сети, называется консенсус, и детально объяснен в разделе:
section.

Чтобы убедиться, что транзакция записана в реестр, вернитесь к
query.js и измените аргумент с CAR4 на CAR12.

Иными словами, измените это:

const result = await contract.evaluateTransaction('queryCar', 'CAR4');

На это:

const result = await contract.evaluateTransaction('queryCar', 'CAR12');

Еще раз сохраните, затем запросите:

И в качестве результата получите:

Wallet path: ...fabric-samples/fabcar/javascript/wallet
Transaction has been evaluated, result is:
{"color":"Black","docType":"car","make":"Honda","model":"Accord","owner":"Tom"}

Поздравляем! Вы создали машину и убедились, что она записана в реестр!

Продолжая, давайте предположим, что Том, поступая щедро, решил подарить свою машину
Honda Accord некоему Дейву.

Чтобы сделать это, вернемся к invoke.js и изменим транзакцию смарт-контракта с: createCar на changeCarOwner, изменив следующие входные данные:

await contract.submitTransaction('changeCarOwner', 'CAR12', 'Dave');

Первый аргумент — CAR12 — обозначает машину, у которой сменится владелец.
Второй аргумент — Dave — определит нового владельца машины.

Сохраните и запустите программу снова:

Теперь давайте запросим реестр опять и убедимся, что Дейв теперь связан с ключом машины
CAR12 :

Должен получиться следующий результат:

Wallet path: ...fabric-samples/fabcar/javascript/wallet
Transaction has been evaluated, result is:
{"color":"Black","docType":"car","make":"Honda","model":"Accord","owner":"Dave"}

Принадлежность CAR12 перешла от Тома к Дейву.

Примечание

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

Убрать за собой¶

После окончания использования программы FabCar, вы можете остановить сеть, используя
скрипт networkDown.sh.

Эта команда остановит УЦ, узлы и узел упорядочивающей службы созданной нами сети.
Она также удалит шифрованный материал пользователей admin и appUser из
директории wallet. Заметьте, что и все данные из реестра будут утеряны.
Если вы захотите снова пройти по шагам руководства, вы начнете с чистого начального состояния.

Итог¶

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

Дополнительные ресурсы¶

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

Источник