blockChain/Block.cpp at master · SozinM/blockChain · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include "Block.h"
#include <QCryptographicHash>
#include <QString>
#include <QDataStream>

Block::Block(int index, QByteArray prevHash, QVariant data, int nonce)
{
    m_index = index;
    m_prevHash = prevHash;
    m_data = data;
    m_nonce = nonce;
}

Block::Block()
{
    m_index = -1;
    m_prevHash = QByteArray();
    m_data = -1;
    m_nonce = -1;
}


int Block::index() const
{
    return m_index;
}

void Block::setIndex(int index)
{
    m_index = index;
}

int Block::nonce() const
{
    return m_nonce;
}

void Block::setNonce(int nonce)
{
    m_nonce = nonce;
}

QVariant Block::data() const
{
    return m_data;
}

void Block::setData(const QVariant &data)
{
    m_data = data;
}

QByteArray Block::prevHash() const
{
    return m_prevHash;
}

void Block::setPrevHash(const QByteArray &prevHash)
{
    m_prevHash = prevHash;
}

QByteArray Block::hash() const
{
//    строка для хэширования
    QString preHash = QString ("%1%2%3%4").arg(m_index)
                        .arg(QString::fromStdString(m_prevHash.toStdString()))
                        .arg(m_data.toString())
                        .arg(m_nonce);

    return QCryptographicHash::hash(QByteArray::fromStdString(preHash.toStdString()),
                                    QCryptographicHash::Sha256).toHex();
}

QByteArray Block::hash(int nonce) const
{
    QString preHash = QString ("%1%2%3%4").arg(m_index)
                        .arg(QString::fromStdString(m_prevHash.toStdString()))
                        .arg(m_data.toString())
                        .arg(nonce);

    return QCryptographicHash::hash(QByteArray::fromStdString(preHash.toStdString()),
                                    QCryptographicHash::Sha256).toHex();
}

QByteArray Block::toByteArray() const
{
    QByteArray blockAsByteArray;
    QByteArray indexAsByteArray;
    QDataStream streamForIndex(&indexAsByteArray,QIODevice::WriteOnly);
    streamForIndex << m_index;
    blockAsByteArray.append(indexAsByteArray);
    blockAsByteArray.append(m_prevHash);
    QByteArray nonceAsByteArray;
    QDataStream streamForNonce(&nonceAsByteArray, QIODevice::WriteOnly);
    streamForNonce << m_nonce;
    blockAsByteArray.append(nonceAsByteArray);
    //data нужно добавлять последней поскольку все остальные поля имеют фиксированный размер
    blockAsByteArray.append(m_data.toByteArray());

    return  blockAsByteArray;
}

const Block Block::fromByteArray(const QByteArray &byteArray)
{
    Block block;
        int offset = 0;
        QDataStream streamForIndex(byteArray.mid(offset, sizeof(int)));
        int index = 0;
        streamForIndex >> index;
        block.setIndex(index);
        offset += sizeof(int);
        block.setPrevHash(byteArray.mid(offset,
                          QCryptographicHash::hashLength(QCryptographicHash::Sha512)));
        offset += QCryptographicHash::hashLength(QCryptographicHash::Sha512);
        QDataStream streamForNonce(byteArray.mid(offset,sizeof(int)));
        int nonce = 0;
        streamForNonce >> nonce;
        block.setNonce(nonce);
        offset += sizeof(int);
        block.setData(byteArray.mid(offset,byteArray.size()-offset));

    return block;
}