Как написать майнер на python

С точки зрения дилетантов, биткойн — это бухгалтерская книга. Гроссбух — это набор транзакций. Давайте разберемся в этом на примере.

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

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

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

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

Blockchain and Transactions

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

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

Скажем, есть цепочка из пяти блоков — Блок1, Блок2, Блок3, Блок4 и Блок5. Тогда Блок1 будет указывать на Блок2, Блок2 будет указывать на Блок3 и так далее.

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

Биткойн Криптография и Майнинг

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

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

На Python мы можем сгенерировать это хэш-значение с помощью приведенного ниже кода:

from hashlib import sha256
text = "XYZ"
print(sha256(text.encode('ascii')).hexdigest)

В bitcoin блок состоит не только из набора транзакций. В нём есть как предыдущий хэш, так и nonce (число один раз).

Я объясню, что такое «нонс», но сначала пойми это. Мы преобразовываем все в блоке в строку и генерируем хэш для этого блока. В любой момент времени есть особое требование, чтобы сгенерированный хэш имел в начале x число нулей.

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

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

В чем польза от добычи биткойна?

Майнеры получают биткойны для добычи блока. В 2009 году за добычу одного блока ты получишь 50 BTC. В 2012 году он был сокращен до 25 BTC.

Каждые четыре года награда уменьшается вдвое за добычу одного блока. В 2020 году награда была снижена до 6,25 BTC. Но за последние несколько лет bitcoin оценили очень высоко. Даже 6,25 BTC за блок означает 280 000 долларов (на момент публикации). Это довольно много денег за такую работу.

Многие люди по всему миру занимаются добычей биткойн. Это не очень сложно, но это трудоёмкая задача. Нужно много вычислительной мощности, чтобы получить правильную стоимость. Если 10 человек занимаются угадыванием, то тот, кто получит результат первым, выиграет награду.

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

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

from hashlib import sha256
MAX_NONCE_VALUE = 100000000000
def SHA256(text):
    return sha256(text.encode("asci")).hexdigest()def mine(block_number, transactions, previous_hash, prefix_zeros):
    prefix_str = '0'*prefix_zeros
    for nonce in range(MAX_NONCE_VALUE):
     text = str(block_number)+transactions+previous_hash+str(nonce)
     new_hash = SHA256(text)
     if new_hash.startswith(prefix_str):
           print("Bitcoin mined for nonce value of {nonce}")
           return new_hash

Вот так. Мы можем добыть биткойн с этими 12 строками кода в python.

Просмотр кода

Строка 1: Импорт библиотеки sha256 в наш проект.

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

Строка 3-4: Определяем функцию SHA256 для генерации хэш-значения.

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

Строка 6: После добавления требуемого префикса мы создаем еще одну переменную prefix_str для хранения значения Hexa. В дальнейшем эта строка будет использоваться для сравнения с сгенерированным хэшем.

Строка 7-9: A for цикла итерируется для nonce значений для генерации нового хэша с помощью вызова функции SHA256, которую мы сгенерировали на строке 3.

Строка 10-12: Сравниваем только что сгенерированный префикс хэш-значения с нужным. Если он совпадает, то мы распечатываем значение nonce, для которого добывается биткойн, и возвращаем этот сгенерированный хэш.

Заключение

Я взял сложность восьми для тестирования. Приложению пришлось выполнить итерацию около 1,2 миллиона раз, прежде чем оно угадало правильный нон-це.

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

Добыча биткойнов требует специального оборудования. Одними из популярных являются DragonMint T1, Antminer T9+, Antminer R4, Avalon6 и Antminer S9.

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

Оригинал

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

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

Построить граф по логам процесса очень просто. В распоряжении аналитиков в настоящее время достаточное многообразие профессиональных разработок, таких как Celonis, Disco, PM4PY, ProM и т.д., призванных облегчить исследование процессов. Намного сложнее найти отклонения на графах, сделать верные выводы по ним.

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

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

Перед построением графа, необходимо выполнить расчеты. Собственно расчет графа и будет тем самым майнером, о котором говорилось ранее. Для выполнения расчета необходимо собрать знания о событиях — вершинах графа и связях между ними и записать их, например в справочники. Заполняются справочники с помощью процедуры расчета calc (код на github). Заполненные справочники передаются в качестве параметров процедуре отрисовки графов draw (см. код по ссылке выше). Эта процедура форматирует данные, в представленный ниже вид:

digraph f {"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit APPROVED by ADMINISTRATION (4839)" [label=4829 color=black penwidth=4.723857205400346] 
"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit REJECTED by ADMINISTRATION (83)" [label=83 color=pink2 penwidth=2.9590780923760738] 
"Permit SUBMITTED by EMPLOYEE (6255)" -> "Permit REJECTED by EMPLOYEE (231)" [label=2 color=pink2 penwidth=1.3410299956639813] 
…
start [color=blue shape=diamond] 
end [color=blue shape=diamond]}

и передает его для отрисовки графическому движку Graphviz.

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

Считаем данные из лога, отсортируем их по дате и времени. Предварительно формат .xes преобразован в .xlsx.

df_full = pd.read_excel('InternationalDeclarations.xlsx')
df_full = df_full[['id-trace','concept:name','time:timestamp']]
df_full.columns = ['case:concept:name', 'concept:name', 'time:timestamp']
df_full['time:timestamp'] = pd.to_datetime(df_full['time:timestamp'])
df_full = df_full.sort_values(['case:concept:name','time:timestamp'], ascending=[True,True])
df_full = df_full.reset_index(drop=True)

Выполним расчет графа.

dict_tuple_full = calc(df_full)

Выполним отрисовку графа.

draw(dict_tuple_full,'InternationalDeclarations_full')

После выполнения процедур получим граф процесса:

Так как полученный граф не читаем, упростим его.

Есть несколько подходов к улучшению читаемости или упрощению графа:

1. использовать фильтрацию по весам вершин или связей;
2. избавиться от шума;
3. сгруппировать события по схожести названия.

Применим 3 подход.

Создадим словарь объединения событий:

_dict = {'Permit SUBMITTED by EMPLOYEE': 'Permit SUBMITTED',
 'Permit APPROVED by ADMINISTRATION': 'Permit APPROVED',
 'Permit APPROVED by BUDGET OWNER': 'Permit APPROVED',
 'Permit APPROVED by PRE_APPROVER': 'Permit APPROVED',
 'Permit APPROVED by SUPERVISOR': 'Permit APPROVED',
 'Permit FINAL_APPROVED by DIRECTOR': 'Permit FINAL_APPROVED',
 'Permit FINAL_APPROVED by SUPERVISOR': 'Permit FINAL_APPROVED',
 'Start trip': 'Start trip',
 'End trip': 'End trip',
 'Permit REJECTED by ADMINISTRATION': 'Permit REJECTED',
 'Permit REJECTED by BUDGET OWNER': 'Permit REJECTED',
 'Permit REJECTED by DIRECTOR': 'Permit REJECTED',
 'Permit REJECTED by EMPLOYEE': 'Permit REJECTED',
 'Permit REJECTED by MISSING': 'Permit REJECTED',
 'Permit REJECTED by PRE_APPROVER': 'Permit REJECTED',
 'Permit REJECTED by SUPERVISOR': 'Permit REJECTED',
 'Declaration SUBMITTED by EMPLOYEE': 'Declaration SUBMITTED',
 'Declaration SAVED by EMPLOYEE': 'Declaration SAVED',
 'Declaration APPROVED by ADMINISTRATION': 'Declaration APPROVED',
 'Declaration APPROVED by BUDGET OWNER': 'Declaration APPROVED',
 'Declaration APPROVED by PRE_APPROVER': 'Declaration APPROVED',
 'Declaration APPROVED by SUPERVISOR': 'Declaration APPROVED',
 'Declaration FINAL_APPROVED by DIRECTOR': 'Declaration FINAL_APPROVED',
 'Declaration FINAL_APPROVED by SUPERVISOR': 'Declaration FINAL_APPROVED',
 'Declaration REJECTED by ADMINISTRATION': 'Declaration REJECTED',
 'Declaration REJECTED by BUDGET OWNER': 'Declaration REJECTED',
 'Declaration REJECTED by DIRECTOR': 'Declaration REJECTED',
 'Declaration REJECTED by EMPLOYEE': 'Declaration REJECTED',
 'Declaration REJECTED by MISSING': 'Declaration REJECTED',
 'Declaration REJECTED by PRE_APPROVER': 'Declaration REJECTED',
 'Declaration REJECTED by SUPERVISOR': 'Declaration REJECTED',
 'Request Payment': 'Request Payment',
 'Payment Handled': 'Payment Handled',
 'Send Reminder': 'Send Reminder'}

Выполним группировку событий и отрисуем граф процесса еще раз.

df_full_gr = df_full.copy()
df_full_gr['concept:name'] = df_full_gr['concept:name'].map(_dict)
dict_tuple_full_gr = calc(df_full_gr)
draw(dict_tuple_full_gr,'InternationalDeclarations_full_gr'

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

Для ответа на поставленный вопрос отфильтруем граф по интересующим событиям и отрисуем граф процесса еще раз.

df_full_gr_f = df_full_gr[df_full_gr['concept:name'].isin(['Permit SUBMITTED',
                                                            'Permit APPROVED',
                                                            'Permit FINAL_APPROVED',
                                                            'Declaration FINAL_APPROVED',
                                                            'Declaration APPROVED'])]
df_full_gr_f = df_full_gr_f.reset_index(drop=True)
dict_tuple_full_gr_f = calc(df_full_gr_f)
draw(dict_tuple_full_gr_f,'InternationalDeclarations_full_gr_isin')

С помощью полученного графа мы легко сможем дать ответ на поставленный вопрос – 116 и 312 декларациям не предшествовало предодобренное разрешение.

Можно дополнительно “провалиться” (отфильтровать по ‘case:concept:name’, участвующих в нужной связи) за связи 116 и 312 и убедиться, что на графах будут отсутствовать события, связанные с разрешениями.

“Провалимся” за связь 116:

df_116 = df_full_gr_f[df_full_gr_f['case:concept:name'].isin(d_case_start2['Declaration FINAL_APPROVED'])]
df_116 = df_116.reset_index(drop=True)
dict_tuple_116 = calc(df_116)
draw(dict_tuple_116,'InternationalDeclarations_full_gr_isin_116')

“Провалимся” за связь 312:

df_312 = df_full_gr_f[df_full_gr_f['case:concept:name'].isin(d_case_start2['Declaration APPROVED'])]
df_312 = df_312.reset_index(drop=True)
dict_tuple_312 = calc(df_312)
draw(dict_tuple_312,'InternationalDeclarations_full_gr_isin_312')

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

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

In this post, we will learn to build a very simple miner in Python. Of course this miner will be comparatively slow and limited and only be useful in our test network, but it will hopefully help to explain the principles behind mining.

When we want to mine a block, we first need some information on the current state of the blockchain, like the hash of the current last block, the current value of the difficulty or the coin base value, i.e. the number of BTC that we earn when mining the block. When we are done building the block, we need to find a way to submit it into the bitcoin network so that it is accepted by all nodes and permanently added to the chain.

If we were member of a mining pool, there would be a mining server that would provide us the required information. As we want to build a solo mining script, we need to communicate with bitcoin core to get that information and to submit our final block. Fortunately, the RPC interface of bitcoin core offers methods to facilitate that communication that were introduced with BIP22.

First, there is the method getblocktemplate. It will deliver all the required information that we need to build a valid block and even propose transactions that we should include in the block. These transactions will be taken from the so called mempool which is a collection of transactions that the bitcoin server knows which have not been added to a block yet (see miner.cpp/BlockAssembler::addPackageTxs in the bitcoin core source code for details on how the selection process works).

If the client is done building the block, it can submit the final block using the method submitblock. This method will run a couple of checks on the block, for instance that it can be correctly decoded, that the first transaction – and only the first – is a coinbase transaction, that it is not a duplicate and that the proof-of-work is valid. If all the checks pass, it will add the block to the local copy of the blockchain. If a check fails, it will return a corresponding error code to the caller.

With that understanding, let us now write down the processing logic for our simple miner, assuming that we only want to mine one additional block. First, we will use getblocktemplate to get the basic parameters that we need and transaction that we can include. Then we will create a new block and a new coinbase transaction. We then add the coinbase transaction followed by all the other transactions to the block.

Once we have that block, we enter a loop. Within the loop, we calculate the hash of the block and compare this against the target. If we can meet the target, we are done and submit the newly created block using submitblock. Otherwise, we increment the nonce and try again.

We have discussed most of these steps in some details in the previous posts, with one exception – coinbase transactions. A coinbase transaction is, by definition, a transaction which generates bitcoin because it has valid outputs, but does not spend any UTXOs. Technically, a coinbase transaction is a transaction which (see CTransaction::IsCoinBase())

• has exactly one transaction input
• the previous transaction ID in this input is zero (i.e. a hexadecimal string consisting of 32 zeros “00”)
• the index of the previous output is -1 (encoded as  0xFFFFFFFF)

As it does not refer to any output, the signature script of a coinbase transaction will never be executed. It can therefore essentially contain an arbitrary value. The only restriction defined by the protocol is described in BIP34, which defines that the first bytes of the signature script should be a valid script that consists of the height of the new block as pushed data. The remainder of the coinbase signature script (which is limited to 100 bytes in total) can be used by the miner at will.

Many miners use this freedom to solve a problem with the length of the nonce in the block header. Here, the nonce is a 32 bit value, which implies that a miner can try 2³², i.e. roughly 4 billion different combinations. Modern mining hardware based on ASICs can search that range within fractions of seconds, and the current difficulty is so high that it is rather likely that no solution can be found by just changing the nonce. So we have to change other fields in the block header to try out more hashes.

What are good candidates for this? We could of course use the block creation time, but the bitcoin server validates this field and will reject the block if it deviates significantly from the current time. Instead miners typically use the coinbase signature script as an extra nonce that they modify to increase the range of possible hashes. Therefore the fields after the height are often combinations of an extra nonce and additional data, like the name of the mining pool (increasing the extra nonce is a bit less effective than increasing the nonce in the block header, as it changes the hash of the coinbase transactions and therefore forces us to recalculate the Merkle root, therefore this is most often implemented as an outer loop, with the inner loop being the increments of the nonce in the block header).

To illustrate this, let us look at an example. The coinbase signature script of the coinbase transaction in block #400020 is:

03941a060004c75ccf5604a070c007089dcd1424000202660a636b706f6f6c102f426974667572792f4249503130302f

If we decode this, we find that the first part is in fact a valid script and corresponds to the following sequence of instructions (keep in mind that all integers are encoded as little endian within the script):

OP_PUSH 400020
OP_0
OP_PUSH 1456430279
OP_PUSH 130052256
OP_PUSH 7350439741450669469

As specified by BIP34, the first pushed data is the height of that block as expected. After the OP_0, we see another push instruction, pushing the Unix system time corresponding to Thu Feb 25 20:57:59 2016, which is the creation time of the block.

The next pushed data is a bit less obvious. After looking at the source code of the used mining software, I assume that this is the nanoseconds within the second returned by the Unix system call clock_gettime. This is then followed by an eight byte integer (7350439741450669469) which is the extra nonce.

The next part of the signature script is not actually a valid script, but a string – a newline character (0xa), followed by the string “ckpool”. This is a fixed sequence of bytes that indicates the mining software used.

Finally, there is one last push operation which pushes the string “/Bitfury/BIP100/”, which tells us that the block has been mined by the Bitfury pool and that this pool supports BIP100.

Enough theory – let us put this to work! Using the utility functions in my btc Python package, it is now not difficult to write a short program that performs the actual mining.

However, we need some preparations to set up our test environment that are related to our plan to use the getblocktemplate RPC call. This call performs a few validations that can be a bit tricky in a test environment. First, it will verify that the server is connected, i.e. we need at least one peer. So we need to start two docker container, let us call them alice and bob again, and find out the IP address of the container bob in the Docker bridget network. The three following statements should do this for you.

$ docker run --rm -d -p 18332:18332 --name="alice" alice
$ docker run --rm -d  --name="bob" bitcoin-alpine
$ docker network inspect bridge | grep  -A 4  "bob" - | grep "IPv4" -

Assuming that this gives you 172.17.0.3 (replace this with whatever the result is in your case), we can now again use the addnode RPC call to connect the two nodes.

$ bitcoin-cli --rpcuser=user --rpcpassword=password -regtest addnode "172.17.0.3" add

The next validation that the bitcoin server will perform when we ask for a block template is that the local copy of the blockchain is up to date. It does by verifying that the time stamp of the last block in the chain is less than 24 hours in the past. As it is likely that a bit more time has passed since you have created the Alice container, we therefore need to use the mining functionality built into bitcoin core to create at least one new block.

$ bitcoin-cli --rpcuser=user --rpcpassword=password -regtest generate 1

Now we are ready to run our test. The next few lines will download the code from GitHub, create one transaction that will then be included in the block. We will create this transaction using the script SendMoney.py that we have already used in an earlier post.

$ git clone https://github.com/christianb93/bitcoin.git
$ cd bitcoin
$ python SendMoney.py
$ python Miner.py

You should then see an output telling you that a block with two transactions (one coinbase transaction and the transaction that we have generated) was mined, along with the previous height of the blockchain and the new height which should be higher by one.

Let us now verify that everything works. First, let us get the hash of the current last block.

$ bitcoin-cli --rpcuser=user --rpcpassword=password -regtest getchaintips
[
  {
    "height": 109,
    "hash": "07849d5c8ddcdc609d7acc3090bc48bbe4403c36008d46b5a291185334efe1bf",
    "branchlen": 0,
    "status": "active"
  }
]

Take the value from the hash field in the output and feed it into a call to getblock:

$ bitcoin-cli --rpcuser=user --rpcpassword=password -regtest getblock "07849d5c8ddcdc609d7acc3090bc48bbe4403c36008d46b5a291185334efe1bf"
{
  "hash": "07849d5c8ddcdc609d7acc3090bc48bbe4403c36008d46b5a291185334efe1bf",
  "confirmations": 1,
  "strippedsize": 367,
  "size": 367,
  "weight": 1468,
  "height": 109,
  "version": 536870912,
  "versionHex": "20000000",
  "merkleroot": "8769987458af75adc80d6792848e5cd5cb8178a9584157bb4be79b77cda95909",
  "tx": [
    "7ba3186ca8e5aae750614a3211422423a0a217f5999d0de6dfeb8968aeb01900", 
    "1094360149626a421b4ddbc7eb58a815762700316c36407770b96ffc36a7735b"
  ],
  "time": 1522952768,
  "mediantime": 1521904060,
  "nonce": 1,
  "bits": "207fffff",
  "difficulty": 4.656542373906925e-10,
  "chainwork": "00000000000000000000000000000000000000000000000000000000000000dc",
  "previousblockhash": "2277e40bf4c0ebde3fb5f38fcbd384e39df3471ad192cc46f66ea8d8d96327e7"
}

The second entry in the list tx should now match the ID of the newly created transaction which was displayed when executing the SendMoney.py script. This proves that our new transaction has been included in the block.

Congratulations, you have just mined 50 BTC – unfortunately only in your local installation, not in the production network. Of course, real miners work differently, using mining pools to split the work between many different nodes and modern ASICS to achieve the hash rates that you need to be successful in the production network. But at least we have built a simple miner more or less from scratch, relying only on the content of this and the previous posts in this series and without using any of the many Python bitcoin libraries that are out there.

This concludes my current series on the bitcoin blockchain –  I hope you enjoyed the posts and had a bit of fun. If you want to learn more, here are a few excellent sources of information that I recommend.

1. Of course the ultimative source of information is always the bitcoin core source code itself that we have already consulted several times
2. The Bitcoin wiki contains many excellent pages on most of what we have discussed
3. There is of course the original bitcoin paper which you should now be able to read and understand
4. and of course there are tons of good books out there, I personally liked Mastering Bitcoin by A. Antonopoulos which is also available online

#!/usr/bin/python # # Copyright 2011 Jeff Garzik # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; see the file COPYING. If not, write to # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. # import time import json import pprint import hashlib import struct import re import base64 import httplib import sys from multiprocessing import Process ERR_SLEEP = 15 MAX_NONCE = 1000000L settings = {} pp = pprint.PrettyPrinter(indent=4) class BitcoinRPC: OBJID = 1 def __init__(self, host, port, username, password): authpair = «%s:%s» % (username, password) self.authhdr = «Basic %s» % (base64.b64encode(authpair)) self.conn = httplib.HTTPConnection(host, port, False, 30) def rpc(self, method, params=None): self.OBJID += 1 obj = { ‘version’ : ‘1.1’, ‘method’ : method, ‘id’ : self.OBJID } if params is None: obj[‘params’] = [] else: obj[‘params’] = params self.conn.request(‘POST’, ‘/’, json.dumps(obj), { ‘Authorization’ : self.authhdr, ‘Content-type’ : ‘application/json’ }) resp = self.conn.getresponse() if resp is None: print «JSON-RPC: no response» return None body = resp.read() resp_obj = json.loads(body) if resp_obj is None: print «JSON-RPC: cannot JSON-decode body» return None if ‘error’ in resp_obj and resp_obj[‘error’] != None: return resp_obj[‘error’] if ‘result’ not in resp_obj: print «JSON-RPC: no result in object» return None return resp_obj[‘result’] def getblockcount(self): return self.rpc(‘getblockcount’) def getwork(self, data=None): return self.rpc(‘getwork’, data) def uint32(x): return x & 0xffffffffL def bytereverse(x): return uint32(( ((x) << 24) | (((x) << 8) & 0x00ff0000) | (((x) >> 8) & 0x0000ff00) | ((x) >> 24) )) def bufreverse(in_buf): out_words = [] for i in range(0, len(in_buf), 4): word = struct.unpack(‘@I’, in_buf[i:i+4])[0] out_words.append(struct.pack(‘@I’, bytereverse(word))) return ».join(out_words) def wordreverse(in_buf): out_words = [] for i in range(0, len(in_buf), 4): out_words.append(in_buf[i:i+4]) out_words.reverse() return ».join(out_words) class Miner: def __init__(self, id): self.id = id self.max_nonce = MAX_NONCE def work(self, datastr, targetstr): # decode work data hex string to binary static_data = datastr.decode(‘hex’) static_data = bufreverse(static_data) # the first 76b of 80b do not change blk_hdr = static_data[:76] # decode 256-bit target value targetbin = targetstr.decode(‘hex’) targetbin = targetbin[::—1] # byte-swap and dword-swap targetbin_str = targetbin.encode(‘hex’) target = long(targetbin_str, 16) # pre-hash first 76b of block header static_hash = hashlib.sha256() static_hash.update(blk_hdr) for nonce in xrange(self.max_nonce): # encode 32-bit nonce value nonce_bin = struct.pack(«<I», nonce) # hash final 4b, the nonce value hash1_o = static_hash.copy() hash1_o.update(nonce_bin) hash1 = hash1_o.digest() # sha256 hash of sha256 hash hash_o = hashlib.sha256() hash_o.update(hash1) hash = hash_o.digest() # quick test for winning solution: high 32 bits zero? if hash[—4:] != »: continue # convert binary hash to 256-bit Python long hash = bufreverse(hash) hash = wordreverse(hash) hash_str = hash.encode(‘hex’) l = long(hash_str, 16) # proof-of-work test: hash < target if l < target: print time.asctime(), «PROOF-OF-WORK found: %064x» % (l,) return (nonce + 1, nonce_bin) else: print time.asctime(), «PROOF-OF-WORK false positive %064x» % (l,) # return (nonce + 1, nonce_bin) return (nonce + 1, None) def submit_work(self, rpc, original_data, nonce_bin): nonce_bin = bufreverse(nonce_bin) nonce = nonce_bin.encode(‘hex’) solution = original_data[:152] + nonce + original_data[160:256] param_arr = [ solution ] result = rpc.getwork(param_arr) print time.asctime(), «—> Upstream RPC result:», result def iterate(self, rpc): work = rpc.getwork() if work is None: time.sleep(ERR_SLEEP) return if ‘data’ not in work or ‘target’ not in work: time.sleep(ERR_SLEEP) return time_start = time.time() (hashes_done, nonce_bin) = self.work(work[‘data’], work[‘target’]) time_end = time.time() time_diff = time_end — time_start self.max_nonce = long( (hashes_done * settings[‘scantime’]) / time_diff) if self.max_nonce > 0xfffffffaL: self.max_nonce = 0xfffffffaL if settings[‘hashmeter’]: print «HashMeter(%d): %d hashes, %.2f Khash/sec» % ( self.id, hashes_done, (hashes_done / 1000.0) / time_diff) if nonce_bin is not None: self.submit_work(rpc, work[‘data’], nonce_bin) def loop(self): rpc = BitcoinRPC(settings[‘host’], settings[‘port’], settings[‘rpcuser’], settings[‘rpcpass’]) if rpc is None: return while True: self.iterate(rpc) def miner_thread(id): miner = Miner(id) miner.loop() if __name__ == ‘__main__’: if len(sys.argv) != 2: print «Usage: pyminer.py CONFIG-FILE» sys.exit(1) f = open(sys.argv[1]) for line in f: # skip comment lines m = re.search(‘^s*#’, line) if m: continue # parse key=value lines m = re.search(‘^(w+)s*=s*(S.*)$’, line) if m is None: continue settings[m.group(1)] = m.group(2) f.close() if ‘host’ not in settings: settings[‘host’] = ‘127.0.0.1’ if ‘port’ not in settings: settings[‘port’] = 8332 if ‘threads’ not in settings: settings[‘threads’] = 1 if ‘hashmeter’ not in settings: settings[‘hashmeter’] = 0 if ‘scantime’ not in settings: settings[‘scantime’] = 30L if ‘rpcuser’ not in settings or ‘rpcpass’ not in settings: print «Missing username and/or password in cfg file» sys.exit(1) settings[‘port’] = int(settings[‘port’]) settings[‘threads’] = int(settings[‘threads’]) settings[‘hashmeter’] = int(settings[‘hashmeter’]) settings[‘scantime’] = long(settings[‘scantime’]) thr_list = [] for thr_id in range(settings[‘threads’]): p = Process(target=miner_thread, args=(thr_id,)) p.start() thr_list.append(p) time.sleep(1) # stagger threads print settings[‘threads’], «mining threads started» print time.asctime(), «Miner Starts — %s:%s» % (settings[‘host’], settings[‘port’]) try: for thr_proc in thr_list: thr_proc.join() except KeyboardInterrupt: pass print time.asctime(), «Miner Stops — %s:%s» % (settings[‘host’], settings[‘port’])

Самый быстрый способ узнать, как работает блокчейн — это создать его.

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

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

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

Перед тем, как начать…

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

Если вы не знаете, что такое хеш, то вот вам статьи:

• Шифрование и криптография в Python
• Генерация случайных данных в Python (Руководство)

На кого нацелена данная статья?

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

Что нам нужно? Убедитесь, что у вас установлен Python 3.6+ (а также pip). Вам также нужно будет установить Flask и замечательную библиотеку Requests:

И да, вам также нужен будет HTTP клиент, такой как Postman или cURL. В целом, что-нибудь подойдет.

Исходный код статьи

Вот здесь вы можете ознакомиться с исходным: https://github.com/dvf/blockchain

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

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

Скелет блокчейна

Мы создадим класс блокчейна, чей конструктор создает начальный пустой лист (для хранения нашего блокчейна), и еще один — для хранения транзакций. Вот чертёж нашего класса:

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

Как выглядит блок?

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

Вот пример того, как выглядит один блок:

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

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

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

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

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

Создание новых блоков

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

В дополнению к созданию блока генезиса в конструкторе, мы также выкатим методы для new_block(), new_transaction() и hash():

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

Понимание подтверждения работы

Алгоритм пруфа работы (Proof of Work, PoW) — это то, как новые блоки созданы или майнятся в блокчейне. Цель PoW — это найти число, которое решает проблему. Число должно быть таким, чтобы его тяжело было найти, но легко подтвердить (говоря о вычислениях) кем угодно в интернете. Это главная задача алгоритма.

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

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

Решение здесь следующее: y = 21, так как созданный хеш заканчивается нулем:

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

Реализация базового PoW

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

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

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

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

Шаг 2: Блокчейн как API

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

Мы создадим три метода:

• /transactions/new для создания новой транзакции в блоке;
• /mine, чтобы указать серверу, что нужно майнить новый блок;
• /chain для возвращения всего блокчейна

Настройка Flask

Наш “сервер” сформирует единый узел в нашей сети блокчейна. Давайте создадим шаблонный код:

Краткое объяснение того, что мы только что добавили:

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

Конечная точка транзакций

Вот так запрос транзакции должен будет выглядеть. Это то, что пользователь отправляет в сервер:

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

Конечная точка майнинга

Конечная точка майнинга — это часть, где происходит магия, и это просто! Для этого нужно сделать три вещи:

• Подсчитать PoW;
• Наградить майнера (нас), добавив транзакцию, дающую нам 1 коин;
• Слепить следующий блок, внеся его в цепь.

Обратите внимание на то, что получатель замайненого блока — это адрес нашего узла. Большая часть того, что мы здесь сделали, это просто взаимодействие с методами в нашем классе Blockchain. С этого момента, мы закончили, и можем начать взаимодействовать с нашим blockchain на Python.

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

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

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

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

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

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

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

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

Пока всё идет очень здорово. У нас есть базовый blockchain, который принимает транзакции и дает возможность майнить новые блоки. Но вся суть блокчейна в том, что они должны быть децентрализованными. А если они децентрализованы, каким образом мы можем гарантировать, все они отображают одну цепочку?

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

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

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

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

Нам нужно будет изменить конструктор нашего Blockchain и привнести метод для регистрации узлов:

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

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

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

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

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

Давайте зарегистрируем две конечные точки нашего API, одну для внесения соседних узлов, а вторую — для решения конфликтов:

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

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

И это была обертка… Найдите друзей и вместе попробуйте протестировать ваш блокчейн!

Подведем итоги

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