174 lines
4.6 KiB
C++
174 lines
4.6 KiB
C++
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
|
// Copyright (c) 2009-2015 The Bitcoin Core developers
|
|
// Copyright (c) 2014-2017 The Dash Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#ifndef BITCOIN_UINT256_H
|
|
#define BITCOIN_UINT256_H
|
|
|
|
#include <assert.h>
|
|
#include <cstring>
|
|
#include <stdexcept>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
#include <vector>
|
|
#include "crypto/common.h"
|
|
|
|
/** Template base class for fixed-sized opaque blobs. */
|
|
template<unsigned int BITS>
|
|
class base_blob
|
|
{
|
|
protected:
|
|
enum { WIDTH=BITS/8 };
|
|
uint8_t data[WIDTH];
|
|
public:
|
|
base_blob()
|
|
{
|
|
memset(data, 0, sizeof(data));
|
|
}
|
|
|
|
explicit base_blob(const std::vector<unsigned char>& vch);
|
|
|
|
bool IsNull() const
|
|
{
|
|
for (int i = 0; i < WIDTH; i++)
|
|
if (data[i] != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void SetNull()
|
|
{
|
|
memset(data, 0, sizeof(data));
|
|
}
|
|
|
|
friend inline bool operator==(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) == 0; }
|
|
friend inline bool operator!=(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) != 0; }
|
|
friend inline bool operator<(const base_blob& a, const base_blob& b) { return memcmp(a.data, b.data, sizeof(a.data)) < 0; }
|
|
|
|
std::string GetHex() const;
|
|
void SetHex(const char* psz);
|
|
void SetHex(const std::string& str);
|
|
std::string ToString() const;
|
|
|
|
unsigned char* begin()
|
|
{
|
|
return &data[0];
|
|
}
|
|
|
|
unsigned char* end()
|
|
{
|
|
return &data[WIDTH];
|
|
}
|
|
|
|
const unsigned char* begin() const
|
|
{
|
|
return &data[0];
|
|
}
|
|
|
|
const unsigned char* end() const
|
|
{
|
|
return &data[WIDTH];
|
|
}
|
|
|
|
unsigned int size() const
|
|
{
|
|
return sizeof(data);
|
|
}
|
|
|
|
unsigned int GetSerializeSize(int nType, int nVersion) const
|
|
{
|
|
return sizeof(data);
|
|
}
|
|
|
|
template<typename Stream>
|
|
void Serialize(Stream& s, int nType, int nVersion) const
|
|
{
|
|
s.write((char*)data, sizeof(data));
|
|
}
|
|
|
|
template<typename Stream>
|
|
void Unserialize(Stream& s, int nType, int nVersion)
|
|
{
|
|
s.read((char*)data, sizeof(data));
|
|
}
|
|
};
|
|
|
|
/** 160-bit opaque blob.
|
|
* @note This type is called uint160 for historical reasons only. It is an opaque
|
|
* blob of 160 bits and has no integer operations.
|
|
*/
|
|
class uint160 : public base_blob<160> {
|
|
public:
|
|
uint160() {}
|
|
uint160(const base_blob<160>& b) : base_blob<160>(b) {}
|
|
explicit uint160(const std::vector<unsigned char>& vch) : base_blob<160>(vch) {}
|
|
};
|
|
|
|
/** 256-bit opaque blob.
|
|
* @note This type is called uint256 for historical reasons only. It is an
|
|
* opaque blob of 256 bits and has no integer operations. Use arith_uint256 if
|
|
* those are required.
|
|
*/
|
|
class uint256 : public base_blob<256> {
|
|
public:
|
|
uint256() {}
|
|
uint256(const base_blob<256>& b) : base_blob<256>(b) {}
|
|
explicit uint256(const std::vector<unsigned char>& vch) : base_blob<256>(vch) {}
|
|
|
|
/** A cheap hash function that just returns 64 bits from the result, it can be
|
|
* used when the contents are considered uniformly random. It is not appropriate
|
|
* when the value can easily be influenced from outside as e.g. a network adversary could
|
|
* provide values to trigger worst-case behavior.
|
|
*/
|
|
uint64_t GetCheapHash() const
|
|
{
|
|
return ReadLE64(data);
|
|
}
|
|
|
|
/** A more secure, salted hash function.
|
|
* @note This hash is not stable between little and big endian.
|
|
*/
|
|
uint64_t GetHash(const uint256& salt) const;
|
|
};
|
|
|
|
/* uint256 from const char *.
|
|
* This is a separate function because the constructor uint256(const char*) can result
|
|
* in dangerously catching uint256(0).
|
|
*/
|
|
inline uint256 uint256S(const char *str)
|
|
{
|
|
uint256 rv;
|
|
rv.SetHex(str);
|
|
return rv;
|
|
}
|
|
/* uint256 from std::string.
|
|
* This is a separate function because the constructor uint256(const std::string &str) can result
|
|
* in dangerously catching uint256(0) via std::string(const char*).
|
|
*/
|
|
inline uint256 uint256S(const std::string& str)
|
|
{
|
|
uint256 rv;
|
|
rv.SetHex(str);
|
|
return rv;
|
|
}
|
|
|
|
/** 512-bit unsigned big integer. */
|
|
class uint512 : public base_blob<512> {
|
|
public:
|
|
uint512() {}
|
|
uint512(const base_blob<512>& b) : base_blob<512>(b) {}
|
|
explicit uint512(const std::vector<unsigned char>& vch) : base_blob<512>(vch) {}
|
|
|
|
uint256 trim256() const
|
|
{
|
|
uint256 result;
|
|
memcpy((void*)&result, (void*)data, 32);
|
|
return result;
|
|
}
|
|
};
|
|
|
|
|
|
#endif // BITCOIN_UINT256_H
|