lbrycrd/src/uint256.h

159 lines
4.1 KiB
C
Raw Normal View History

2010-07-14 17:54:31 +02:00
// Copyright (c) 2009-2010 Satoshi Nakamoto
2015-12-13 17:58:29 +01:00
// Copyright (c) 2009-2015 The Bitcoin 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>
2010-07-14 17:54:31 +02:00
#include <string>
#include <vector>
#include "crypto/common.h"
/** Template base class for fixed-sized opaque blobs. */
2010-07-14 17:54:31 +02:00
template<unsigned int BITS>
class base_blob
2010-07-14 17:54:31 +02:00
{
protected:
enum { WIDTH=BITS/8 };
uint8_t data[WIDTH];
2010-07-14 17:54:31 +02:00
public:
base_blob()
{
memset(data, 0, sizeof(data));
}
explicit base_blob(const std::vector<unsigned char>& vch);
bool IsNull() const
2010-07-14 17:54:31 +02:00
{
for (int i = 0; i < WIDTH; i++)
if (data[i] != 0)
2010-07-14 17:54:31 +02:00
return false;
return true;
}
void SetNull()
2010-07-14 17:54:31 +02:00
{
memset(data, 0, sizeof(data));
2010-07-14 17:54:31 +02:00
}
2016-03-18 05:14:19 +01:00
inline int Compare(const base_blob& other) const { return memcmp(data, other.data, sizeof(data)); }
friend inline bool operator==(const base_blob& a, const base_blob& b) { return a.Compare(b) == 0; }
friend inline bool operator!=(const base_blob& a, const base_blob& b) { return a.Compare(b) != 0; }
friend inline bool operator<(const base_blob& a, const base_blob& b) { return a.Compare(b) < 0; }
2010-07-14 17:54:31 +02:00
std::string GetHex() const;
void SetHex(const char* psz);
void SetHex(const std::string& str);
std::string ToString() const;
2010-07-14 17:54:31 +02:00
unsigned char* begin()
{
return &data[0];
2010-07-14 17:54:31 +02:00
}
unsigned char* end()
{
return &data[WIDTH];
2010-07-14 17:54:31 +02:00
}
const unsigned char* begin() const
{
return &data[0];
}
const unsigned char* end() const
{
return &data[WIDTH];
}
unsigned int size() const
2010-07-14 17:54:31 +02:00
{
return sizeof(data);
}
2010-07-14 17:54:31 +02:00
unsigned int GetSerializeSize(int nType, int nVersion) const
2010-07-14 17:54:31 +02:00
{
return sizeof(data);
2010-07-14 17:54:31 +02:00
}
template<typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const
2010-07-14 17:54:31 +02:00
{
s.write((char*)data, sizeof(data));
2010-07-14 17:54:31 +02:00
}
template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersion)
2010-07-14 17:54:31 +02:00
{
s.read((char*)data, sizeof(data));
}
2010-07-14 17:54:31 +02:00
};
/** 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> {
2010-07-14 17:54:31 +02:00
public:
uint160() {}
uint160(const base_blob<160>& b) : base_blob<160>(b) {}
explicit uint160(const std::vector<unsigned char>& vch) : base_blob<160>(vch) {}
2010-07-14 17:54:31 +02:00
};
/** 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> {
2010-07-14 17:54:31 +02:00
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;
2010-07-14 17:54:31 +02:00
};
/* 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;
}
#endif // BITCOIN_UINT256_H