создатель писал возьмите хеш предыдущего, возьмите корень меркле, и случайное число, и получите хеш следующего блока, но это не работает! все данные есть в сети, но на данных из сети это не работает))) уже более 10 лет прошло, а я так и не нашел ответа)))
хеш предыдущего + хеш от всех транзакций из мемпула, входящих в текущий блок + таймштамп + значение нонсе
от всего этого берется хеш
если он соответствует требования сложности (какое то количество первых знаков должно быть равно “0”), то считается валидным и транслируется в сеть.
скажите вы сами то проверяли ?))) я попытался из 500к получить 500.001 как описано например где то в сети, и получается другой хеш хоть и с нолями… ))) вроде как все работает, но не у меня))) если прям еще и код для ардуино или esp выложите с библиотекой нужной будет вообще супер))) тем более вроде и на с++ выкладывали код, типо рабочий)))
нет, сам не проверял, информация из вайтлиста биткоина за 2009 год)
подозреваю, что в любом опенсорсном кошельке ответ на ваш вопрос будет вполне рабочим.
извините)
Однако я порыл и нашел, только хеширующую либу надо другую подключить, это похоже для компа программа писалась судя по хидерам.
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdint>
#include <cstring>
#include <openssl/sha.h>
#include <boost/algorithm/hex.hpp>
using namespace std;
class Blockheader {
public:
uint32_t version;
char previous_block[32];
char merkel_root[32];
uint32_t timestamp;
uint32_t difficulty;
uint32_t nonce;
Blockheader(
uint32_t version,
char previous_block[32],
char merkel_root[32],
uint32_t timestamp,
uint32_t difficulty,
uint32_t nonce);
int computeHash(unsigned char result[32]);
};
Blockheader::Blockheader(
uint32_t version,
char previous_block[32],
char merkel_root[32],
uint32_t timestamp,
uint32_t difficulty,
uint32_t nonce)
{
this->version = version;
memcpy(&this->previous_block, previous_block, 32);
memcpy(&this->merkel_root, merkel_root, 32);
this->timestamp = timestamp;
this->difficulty = difficulty;
this->nonce = nonce;
}
int Blockheader::computeHash(unsigned char result[32])
{
char buffer[80];
memcpy(&buffer[0], &this->version, 4);
memcpy(&buffer[4], &this->previous_block, 32);
memcpy(&buffer[36], &this->merkel_root, 32);
memcpy(&buffer[68], &this->timestamp, 4);
memcpy(&buffer[72], &this->difficulty, 4);
memcpy(&buffer[76], &this->nonce, 4);
char hashTmp[32];
SHA256((const unsigned char*)buffer, 80, (unsigned char*)hashTmp);
SHA256((const unsigned char*)hashTmp, 32, (unsigned char *)result);
return 0;
}
int main()
{
uint32_t version = 0x00000001;
char previous_hash[32];
char merkel_root[32];
string hashHex = boost::algorithm::unhex(string("81cd02ab7e569e8bcd9317e2fe99f2de44d49ab2b8851ba4a308000000000000"));
copy(hashHex.begin(), hashHex.end(), previous_hash);
hashHex = boost::algorithm::unhex(string("e320b6c2fffc8d750423db8b1eb942ae710e951ed797f7affc8892b0f1fc122b"));
copy(hashHex.begin(), hashHex.end(), merkel_root);
uint32_t timestamp = 0x4dd7f5c7;
uint32_t difficulty = 0x1a44b9f2;
uint32_t nonce = 0x9546a142;
Blockheader blockheader(version, previous_hash, merkel_root, timestamp, difficulty, nonce);
unsigned char result[32];
blockheader.computeHash(result);
for (int i = 0; i < 32; i++) {
cout << setfill('0') << setw(2) << hex << (unsigned int)result[i];
}
cout << endl;
}
#include <SHA256.h> // library for SHA-256 hashing
#include <String.h> // library for string manipulation
// Define the Bitcoin block header structure
struct BlockHeader {
uint32_t version;
uint256 prevBlockHash;
uint256 merkleRoot;
uint32_t timestamp;
uint32_t bits;
uint32_t nonce;
};
// Function to calculate the SHA-256 hash of a block header
uint256 calculateHash(struct BlockHeader header) {
uint256 hash;
SHA256 sha256;
sha256.reset();
sha256.update((uint8_t*)&header, sizeof(header));
sha256.finalize((uint8_t*)&hash, sizeof(hash));
return hash;
}
// Function to verify a Bitcoin block
bool verifyBlock(struct BlockHeader header) {
// Calculate the hash of the block header
uint256 hash = calculateHash(header);
// Check if the hash meets the difficulty target
uint256 target;
target = ~uint256(0) >> (256 - header.bits);
if (hash > target) {
return false; // block is not valid
}
// Check if the block hash is less than or equal to the target
if (hash <= target) {
return true; // block is valid
}
return false; // block is not valid
}
void setup() {
Serial.begin(9600);
}
void loop() {
// Example block header data (replace with actual data)
struct BlockHeader header;
header.version = 2;
header.prevBlockHash = uint256("0x0000000000000000000000000000000000000000000000000000000000000000");
header.merkleRoot = uint256("0x0000000000000000000000000000000000000000000000000000000000000000");
header.timestamp = 1643723400;
header.bits = 486604799;
header.nonce = 0;
// Verify the block
bool isValid = verifyBlock(header);
if (isValid) {
Serial.println("Block is valid!");
} else {
Serial.println("Block is not valid!");
}
delay(1000);
}
// от чата https://claude-ai.ru/ один из 10ка кодов, проблема в том что это не работает, даже если попытаться в ручную это все хешировать... и естественно подставив значения нужные...`
проблема в том что метод проверки не работает))) и если кому то будет нечем заняться, и захочет поупражняться с кодом, то вот вам тема)))
функция
bool verifyBlock(struct BlockHeader header)
из кода выше. она не проверяет хеш, она проверяет соответствие хеша текущей сложности. равенство хешей сравнивается побайтово, это массивы байт вроде.