tools::base58 Namespace Reference

Functions
std::string	encode (const std::string &data)
bool	decode (const std::string &enc, std::string &data)
std::string	encode_addr (uint64_t tag, const std::string &data)
bool	decode_addr (const std::string &addr, uint64_t &tag, std::string &data)

Function Documentation

decode()

bool tools::base58::decode	(	const std::string &	enc,
		std::string &	data )

Definition at line 196 of file base58.cpp.

    {
      if (enc.empty())
      {
        data.clear();
        return true;
      }
 
      size_t full_block_count = enc.size() / full_encoded_block_size;
      size_t last_block_size = enc.size() % full_encoded_block_size;
      int last_block_decoded_size = decoded_block_sizes::instance(last_block_size);
      if (last_block_decoded_size < 0)
        return false; // Invalid enc length
      size_t data_size = full_block_count * full_block_size + last_block_decoded_size;
 
      data.resize(data_size, 0);
      for (size_t i = 0; i < full_block_count; ++i)
      {
        if (!decode_block(enc.data() + i * full_encoded_block_size, full_encoded_block_size, &data[i * full_block_size]))
          return false;
      }
 
      if (0 < last_block_size)
      {
        if (!decode_block(enc.data() + full_block_count * full_encoded_block_size, last_block_size,
          &data[full_block_count * full_block_size]))
          return false;
      }
 
      return true;
    }

Here is the caller graph for this function:

decode_addr()

bool tools::base58::decode_addr	(	const std::string &	addr,
		uint64_t &	tag,
		std::string &	data )

Definition at line 238 of file base58.cpp.

    {
      std::string addr_data;
      bool r = decode(addr, addr_data);
      if (!r) return false;
      if (addr_data.size() <= addr_checksum_size) return false;
 
      std::string checksum(addr_checksum_size, '\0');
      checksum = addr_data.substr(addr_data.size() - addr_checksum_size);
 
      addr_data.resize(addr_data.size() - addr_checksum_size);
      crypto::hash hash = crypto::cn_fast_hash(addr_data.data(), addr_data.size());
      std::string expected_checksum(reinterpret_cast<const char*>(&hash), addr_checksum_size);
      if (expected_checksum != checksum) return false;
 
      int read = tools::read_varint(addr_data.begin(), addr_data.end(), tag);
      if (read <= 0) return false;
 
      data = addr_data.substr(read);
      return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

encode()

std::string tools::base58::encode

(

const std::string &

data

)

Definition at line 173 of file base58.cpp.

    {
      if (data.empty())
        return std::string();
 
      size_t full_block_count = data.size() / full_block_size;
      size_t last_block_size = data.size() % full_block_size;
      size_t res_size = full_block_count * full_encoded_block_size + encoded_block_sizes[last_block_size];
 
      std::string res(res_size, alphabet[0]);
      for (size_t i = 0; i < full_block_count; ++i)
      {
        encode_block(data.data() + i * full_block_size, full_block_size, &res[i * full_encoded_block_size]);
      }
 
      if (0 < last_block_size)
      {
        encode_block(data.data() + full_block_count * full_block_size, last_block_size, &res[full_block_count * full_encoded_block_size]);
      }
 
      return res;
    }

Here is the caller graph for this function:

encode_addr()

std::string tools::base58::encode_addr	(	uint64_t	tag,
		const std::string &	data )

Definition at line 228 of file base58.cpp.

    {
      std::string buf = get_varint_data(tag);
      buf += data;
      crypto::hash hash = crypto::cn_fast_hash(buf.data(), buf.size());
      const char* hash_data = reinterpret_cast<const char*>(&hash);
      buf.append(hash_data, addr_checksum_size);
      return encode(buf);
    }

Here is the call graph for this function:

Here is the caller graph for this function: