本文整理汇总了C++中CBigNum::getvch方法的典型用法代码示例。如果您正苦于以下问题：C++ CBigNum::getvch方法的具体用法？C++ CBigNum::getvch怎么用？C++ CBigNum::getvch使用的例子？那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类CBigNum的用法示例。
在下文中一共展示了CBigNum::getvch方法的8个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: i
bool Base58::raw_decode (char const* first, char const* last, void* dest,
std::size_t size, bool checked, Alphabet const& alphabet)
{
CAutoBN_CTX pctx;
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
// Convert big endian string to bignum
for (char const* p = first; p != last; ++p)
{
int i (alphabet.from_char (*p));
if (i == -1)
return false;
bnChar.setuint ((unsigned int) i);
int const success (BN_mul (&bn, &bn, &bn58, pctx));
assert (success);
(void) success;
bn += bnChar;
}
// Get bignum as little endian data
Blob vchTmp = bn.getvch ();
// Trim off sign byte if present
if (vchTmp.size () >= 2 && vchTmp.end ()[-1] == 0 && vchTmp.end ()[-2] >= 0x80)
vchTmp.erase (vchTmp.end () - 1);
char* const out (static_cast <char*> (dest));
// Count leading zeros
int nLeadingZeros = 0;
for (char const* p = first; p!=last && *p==alphabet[0]; p++)
nLeadingZeros++;
// Verify that the size is correct
if (vchTmp.size() + nLeadingZeros != size)
return false;
// Fill the leading zeros
memset (out, 0, nLeadingZeros);
// Copy little endian data to big endian
std::reverse_copy (vchTmp.begin (), vchTmp.end (),
out + nLeadingZeros);
if (checked)
{
char hash4 [4];
fourbyte_hash256 (hash4, out, size - 4);
if (memcmp (hash4, out + size - 4, 4) != 0)
return false;
}
return true;
}示例2: bignum_error
bool Base58::decode (const char* psz, Blob& vchRet, Alphabet const& alphabet)
{
CAutoBN_CTX pctx;
vchRet.clear ();
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
while (isspace (*psz))
psz++;
// Convert big endian string to bignum
for (const char* p = psz; *p; p++)
{
// VFALCO TODO Make this use the inverse table!
// Or better yet ditch this and call raw_decode
//
const char* p1 = strchr (alphabet.chars(), *p);
if (p1 == nullptr)
{
while (isspace (*p))
p++;
if (*p != '\0')
return false;
break;
}
bnChar.setuint (p1 - alphabet.chars());
if (!BN_mul (&bn, &bn, &bn58, pctx))
throw bignum_error ("DecodeBase58 : BN_mul failed");
bn += bnChar;
}
// Get bignum as little endian data
Blob vchTmp = bn.getvch ();
// Trim off sign byte if present
if (vchTmp.size () >= 2 && vchTmp.end ()[-1] == 0 && vchTmp.end ()[-2] >= 0x80)
vchTmp.erase (vchTmp.end () - 1);
// Restore leading zeros
int nLeadingZeros = 0;
for (const char* p = psz; *p == alphabet.chars()[0]; p++)
nLeadingZeros++;
vchRet.assign (nLeadingZeros + vchTmp.size (), 0);
// Convert little endian data to big endian
std::reverse_copy (vchTmp.begin (), vchTmp.end (), vchRet.end () - vchTmp.size ());
return true;
}示例3: bignum_error
inline bool DecodeBase58(const char* psz, vector<unsigned char>& vchRet)
{
CAutoBN_CTX pctx;
vchRet.clear();
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
while (isspace(*psz))
psz++;
// Convert big endian string to bignum
for (const char* p = psz; *p; p++)
{
const char* p1 = strchr(pszBase58, *p);
if (p1 == NULL)
{
while (isspace(*p))
p++;
if (*p != '\0')
return false;
break;
}
bnChar.setulong(p1 - pszBase58);
if (!BN_mul(&bn, &bn, &bn58, pctx))
throw bignum_error("DecodeBase58 : BN_mul failed");
bn += bnChar;
}
// Get bignum as little endian data
vector<unsigned char> vchTmp = bn.getvch();
// Trim off sign byte if present
if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
vchTmp.erase(vchTmp.end()-1);
// Restore leading zeros
int nLeadingZeros = 0;
for (const char* p = psz; *p == pszBase58[0]; p++)
nLeadingZeros++;
vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
// Convert little endian data to big endian
reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
return true;
}示例4: verify
static bool verify(const CBigNum& bignum, const CScriptNum& scriptnum)
{
return bignum.getvch() == scriptnum.getvch() && bignum.getint() == scriptnum.getint();
}示例5: EvalScript
bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType)
{
CAutoBN_CTX pctx;
CScript::const_iterator pc = script.begin();
CScript::const_iterator pend = script.end();
CScript::const_iterator pbegincodehash = script.begin();
opcodetype opcode;
valtype vchPushValue;
vector<bool> vfExec;
vector<valtype> altstack;
if (script.size() > 10000)
return false;
int nOpCount = 0;
try
{
while (pc < pend)
{
bool fExec = !count(vfExec.begin(), vfExec.end(), false);
//
// Read instruction
//
if (!script.GetOp(pc, opcode, vchPushValue))
return false;
if (vchPushValue.size() > 520)
return false;
if (opcode > OP_16 && ++nOpCount > 201)
return false;
if (opcode == OP_CAT ||
opcode == OP_SUBSTR ||
opcode == OP_LEFT ||
opcode == OP_RIGHT ||
opcode == OP_INVERT ||
opcode == OP_AND ||
opcode == OP_OR ||
opcode == OP_XOR ||
opcode == OP_2MUL ||
opcode == OP_2DIV ||
opcode == OP_MUL ||
opcode == OP_DIV ||
opcode == OP_MOD ||
opcode == OP_LSHIFT ||
opcode == OP_RSHIFT)
return false;
if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4)
stack.push_back(vchPushValue);
else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
switch (opcode)
{
//
// Push value
//
case OP_1NEGATE:
case OP_1:
case OP_2:
case OP_3:
case OP_4:
case OP_5:
case OP_6:
case OP_7:
case OP_8:
case OP_9:
case OP_10:
case OP_11:
case OP_12:
case OP_13:
case OP_14:
case OP_15:
case OP_16:
{
// ( -- value)
CBigNum bn((int)opcode - (int)(OP_1 - 1));
stack.push_back(bn.getvch());
}
break;
//
// Control
//
case OP_NOP:
case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
break;
case OP_IF:
case OP_NOTIF:
{
// <expression> if [statements] [else [statements]] endif
bool fValue = false;
if (fExec)
{
if (stack.size() < 1)
return false;
valtype& vch = stacktop(-1);
fValue = CastToBool(vch);
//.........这里部分代码省略.........
示例6: BitcoinMiner2_mineProbableChain
//.........这里部分代码省略.........
mpz_mul_ui(mpzChainOrigin.get_mpz_t(), mpzFinalFixedMultiplier.get_mpz_t(), multiplier);
nChainLengthCunningham1 = 0;
nChainLengthCunningham2 = 0;
nChainLengthBiTwin = 0;
bool canSubmitAsShare = ProbablePrimeChainTestFast2(mpzChainOrigin, testParams, sieveFlags, multiplier);
nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin);
if( nProbableChainLength >= 0x01000000 )
debugStats_primes++;
debugStats_multipliersTested++;
//bool canSubmitAsShare = ProbablePrimeChainTestFast(mpzChainOrigin, testParams);
//CBigNum bnChainOrigin;
//bnChainOrigin.SetHex(mpzChainOrigin.get_str(16));
//bool canSubmitAsShare = ProbablePrimeChainTestBN(bnChainOrigin, block->serverData.nBitsForShare, false, nChainLengthCunningham1, nChainLengthCunningham2, nChainLengthBiTwin);
if( nProbableChainLength >= 0x04000000 )
{
sint32 chainDif = (nProbableChainLength>>24) - 7;
primeStats.nChainHit += pow(8, (float)chainDif);
//primeStats.nChainHit += pow(8, ((float)((double)nProbableChainLength / (double)0x1000000))-7.0);
//primeStats.nChainHit += pow(8, floor((float)((double)nProbableChainLength / (double)0x1000000)) - 7);
nTests = 0;
primeStats.fourChainCount ++;
if (nProbableChainLength >= 0x5000000)
{
primeStats.fiveChainCount ++;
if (nProbableChainLength >= 0x6000000)
{
primeStats.sixChainCount ++;
if (nProbableChainLength >= 0x7000000)
primeStats.sevenChainCount ++;
}
}
}
//if( nBitsGen >= 0x03000000 )
// printf("%08X\n", nBitsGen);
primeStats.primeChainsFound++;
//if( nProbableChainLength > 0x03000000 )
// primeStats.qualityPrimesFound++;
if( nProbableChainLength > primeStats.bestPrimeChainDifficulty )
primeStats.bestPrimeChainDifficulty = nProbableChainLength;
if(nProbableChainLength >= block->serverData.nBitsForShare)
{
// note: mpzPrimeChainMultiplier does not include the blockHash multiplier
mpz_div(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzChainOrigin.get_mpz_t(), mpzHash.get_mpz_t());
//mpz_lsh(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzFixedMultiplier.get_mpz_t(), multiplier);
// update server data
block->serverData.client_shareBits = nProbableChainLength;
// generate block raw data
uint8 blockRawData[256] = {0};
memcpy(blockRawData, block, 80);
uint32 writeIndex = 80;
sint32 lengthBN = 0;
CBigNum bnPrimeChainMultiplier;
bnPrimeChainMultiplier.SetHex(block->mpzPrimeChainMultiplier.get_str(16));
std::vector<unsigned char> bnSerializeData = bnPrimeChainMultiplier.getvch();
lengthBN = bnSerializeData.size();
*(uint8*)(blockRawData+writeIndex) = (uint8)lengthBN; // varInt (we assume it always has a size low enough for 1 byte)
writeIndex += 1;
memcpy(blockRawData+writeIndex, &bnSerializeData[0], lengthBN);
writeIndex += lengthBN;
// switch endianness
for(uint32 f=0; f<256/4; f++)
{
*(uint32*)(blockRawData+f*4) = _swapEndianessU32(*(uint32*)(blockRawData+f*4));
}
time_t now = time(0);
struct tm * timeinfo;
timeinfo = localtime (&now);
char sNow [80];
strftime (sNow, 80, "%x - %X",timeinfo);
printf("%s - SHARE FOUND !!! (Th#: %u Multiplier: %d Layer: %d) --- DIFF: %f %s %s\n",
sNow, threadIndex, multiplier, cSieve->currentSieveLayerIdx, (float)((double)nProbableChainLength / (double)0x1000000),
nProbableChainLength >= 0x6000000 ? ">6":"", nProbableChainLength >= 0x7000000 ? ">7":"");
// submit this share
if (jhMiner_pushShare_primecoin(blockRawData, block))
primeStats.foundShareCount ++;
//printf("Probable prime chain found for block=%s!!\n Target: %s\n Length: (%s %s %s)\n", block.GetHash().GetHex().c_str(),TargetToString(block.nBits).c_str(), TargetToString(nChainLengthCunningham1).c_str(), TargetToString(nChainLengthCunningham2).c_str(), TargetToString(nChainLengthBiTwin).c_str());
//nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin);
// since we are using C structs here we have to make sure the memory for the CBigNum in the block is freed again
//delete *psieve;
//*psieve = NULL;
//block->bnPrimeChainMultiplier = NULL;
RtlZeroMemory(blockRawData, 256);
//delete *psieve;
//*psieve = NULL;
// dont quit if we find a share, there could be other shares in the remaining prime candidates
nTests = 0; // tehere is a good chance to find more shares so search a litle more.
//block->nonce++;
//return true;
//break;
//if (multipleShare)
}
}示例7: operator
/*
bool Evaluator::operator()(const Script& script, const Script& tmpl) {
_begin = script.begin();
_current = script.begin();
_end = script.end();
Script::const_iterator current = tmpl.begin();
// step through the script and template -
}
*/
boost::tribool Evaluator::eval(opcodetype opcode) {
switch (opcode) {
// Push value
case OP_1NEGATE:
case OP_1:
case OP_2:
case OP_3:
case OP_4:
case OP_5:
case OP_6:
case OP_7:
case OP_8:
case OP_9:
case OP_10:
case OP_11:
case OP_12:
case OP_13:
case OP_14:
case OP_15:
case OP_16: {
// ( -- value)
CBigNum bn((int)opcode - (int)(OP_1 - 1));
_stack.push_back(bn.getvch());
break;
}
// Control
case OP_NOP:
case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
break;
case OP_IF:
case OP_NOTIF: {
// <expression> if [statements] [else [statements]] endif
bool fValue = false;
if (_exec) {
if (_stack.size() < 1)
return false;
Value& vch = top(-1);
fValue = CastToBool(vch);
if (opcode == OP_NOTIF)
fValue = !fValue;
pop(_stack);
}
_exec_stack.push_back(fValue);
break;
}
case OP_ELSE: {
if (_exec_stack.empty())
return false;
_exec_stack.back() = !_exec_stack.back();
break;
}
case OP_ENDIF: {
if (_exec_stack.empty())
return false;
_exec_stack.pop_back();
break;
}
case OP_VERIFY: {
// (true -- ) or
// (false -- false) and return
if (_stack.size() < 1)
return false;
bool fValue = CastToBool(top(-1));
if (fValue)
pop(_stack);
else
return false;
break;
}
case OP_RETURN: {
return false;
break;
}
// Stack ops
case OP_TOALTSTACK: {
if (_stack.size() < 1)
return false;
_alt_stack.push_back(top(-1));
pop(_stack);
break;
}
//.........这里部分代码省略.........
示例8: DecodeBase58
bool DecodeBase58(const char* psz, std::vector<unsigned char>& vchRet) {
CAutoBN_CTX pctx;
vchRet.clear();
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
// Skip leading spaces.
while (*psz && isspace(*psz))
psz++;
// Skip and count leading '1's.
int zeroes = 0;
while (*psz == '1') {
zeroes++;
psz++;
}
// Convert big endian string to bignum
for (const char* p = psz; *p; p++)
{
const char* p1 = strchr(pszBase58, *p);
if (p1 == NULL)
{
while (isspace(*p))
p++;
if (*p != '\0')
return false;
break;
}
bnChar.setulong(p1 - pszBase58);
if (!BN_mul(&bn, &bn, &bn58, pctx))
throw bignum_error("DecodeBase58 : BN_mul failed");
bn += bnChar;
}
// Get bignum as little endian data
std::vector<unsigned char> vchTmp = bn.getvch();
// Trim off sign byte if present
if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
vchTmp.erase(vchTmp.end()-1);
// Restore leading zeros
int nLeadingZeros = 0;
for (const char* p = psz; *p == pszBase58[0]; p++)
nLeadingZeros++;
vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
// Convert little endian data to big endian
reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
return true;
// Allocate enough space in big-endian base256 representation.
std::vector<unsigned char> b256(strlen(psz) * 733 / 1000 + 1); // log(58) / log(256), rounded up.
// Process the characters.
while (*psz && !isspace(*psz)) {
// Decode base58 character
const char *ch = strchr(pszBase58, *psz);
if (ch == NULL)
return false;
// Apply "b256 = b256 * 58 + ch".
int carry = ch - pszBase58;
for (std::vector<unsigned char>::reverse_iterator it = b256.rbegin(); it != b256.rend(); it++) {
carry += 58 * (*it);
*it = carry % 256;
carry /= 256;
}
assert(carry == 0);
psz++;
}
// Skip trailing spaces.
while (isspace(*psz))
psz++;
if (*psz != 0)
return false;
// Skip leading zeroes in b256.
std::vector<unsigned char>::iterator it = b256.begin();
while (it != b256.end() && *it == 0)
it++;
// Copy result into output vector.
vchRet.reserve(zeroes + (b256.end() - it));
vchRet.assign(zeroes, 0x00);
while (it != b256.end())
vchRet.push_back(*(it++));
return true;
}