{

// Skip leading spaces.

while (*psz && IsSpace(*psz))

psz++;

// Skip and count leading '1's.

int zeroes = 0;

int length = 0;

while (*psz == '1') {

zeroes++;

psz++;

}

// Allocate enough space in big-endian base256 representation.

int size = strlen(psz) * 733 /1000 + 1; // log(58) / log(256), rounded up.

std::vector<unsigned char> b256(size);

// Process the characters.

static_assert(sizeof(mapBase58)/sizeof(mapBase58[0]) == 256, "mapBase58.size() should be 256"); // guarantee not out of range

while (*psz && !IsSpace(*psz)) {

// Decode base58 character

int carry = mapBase58[(uint8_t)*psz];

if (carry == -1) // Invalid b58 character

return false;

int i = 0;

for (std::vector<unsigned char>::reverse_iterator it = b256.rbegin(); (carry != 0 || i < length) && (it != b256.rend()); ++it, ++i) {

carry += 58 * (*it);

*it = carry % 256;

carry /= 256;

}

assert(carry == 0);

length = i;

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() + (size - length);

while (it != b256.end() && *it == 0)

it++;

// Copy result into output vector.

vch.reserve(zeroes + (b256.end() - it));

vch.assign(zeroes, 0x00);

while (it != b256.end())

vch.push_back(*(it++));

return true;

{

// Skip & count leading zeroes.

int zeroes = 0;

int length = 0;

while (pbegin != pend && *pbegin == 0) {

pbegin++;

zeroes++;

}

// Allocate enough space in big-endian base58 representation.

int size = (pend - pbegin) * 138 / 100 + 1; // log(256) / log(58), rounded up.

std::vector<unsigned char> b58(size);

// Process the bytes.

while (pbegin != pend) {

int carry = *pbegin;

int i = 0;

// Apply "b58 = b58 * 256 + ch".

for (std::vector<unsigned char>::reverse_iterator it = b58.rbegin(); (carry != 0 || i < length) && (it != b58.rend()); it++, i++) {

carry += 256 * (*it);

*it = carry % 58;

carry /= 58;

}

assert(carry == 0);

length = i;

pbegin++;

}

// Skip leading zeroes in base58 result.

std::vector<unsigned char>::iterator it = b58.begin() + (size - length);

while (it != b58.end() && *it == 0)

it++;

// Translate the result into a string.

std::string str;

str.reserve(zeroes + (b58.end() - it));

str.assign(zeroes, '1');

while (it != b58.end())

str += pszBase58[*(it++)];

return str;

{

// add 4-byte hash check to the end

std::vector<unsigned char> vch(vchIn);

uint256 hash = Hash(vch.begin(), vch.end());

vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);

return EncodeBase58(vch);

{

if (!DecodeBase58(psz, vchRet) ||

(vchRet.size() < 4)) {

vchRet.clear();

return false;

}

// re-calculate the checksum, ensure it matches the included 4-byte checksum

uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);

if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {

vchRet.clear();

return false;

}

vchRet.resize(vchRet.size() - 4);

return true;