Mode.cpp

#include "Mode.hpp"
#include <stdexcept>
#include <iostream>
#include <cassert>

using namespace std;

Mode::Mode() : score(0) {

}

Mode Mode::benchmark() {
	Mode r;
	r.name = "benchmark";
	r.kernel = "profanity_score_benchmark";
	return r;
}

Mode Mode::zeros() {
	Mode r = range(0, 0);
	r.name = "zeros";
	return r;
}

static std::string::size_type hexValueNoException(char c) {
	if (c >= 'A' && c <= 'F') {
		c -= 'A' - 'a';
	}

	const std::string hex = "0123456789abcdef";
	const std::string::size_type ret = hex.find(c);
	return ret;
}

static std::string::size_type hexValue(char c) {
	const std::string::size_type ret = hexValueNoException(c);
	if(ret == std::string::npos) {
		throw std::runtime_error("bad hex value");
	}

	return ret;
}

static unsigned int parseHex(const std::string& strHex) {
	assert(strHex.size() == 8);
	unsigned int ret = 0;
	for (std::string::size_type i = 0; i < strHex.size(); ++i) {
		ret <<= 4;
		ret |= hexValue(strHex[i]);
	}
	return ret;
}

static mp_number parseCoordinate(const std::string& strHex) {
	assert (strHex.size() == 64);

	mp_number c;
	for (size_t w = 0; w < 8; ++w) {
		const std::string word = strHex.substr(w * 8, 8);
		c.d[MP_NWORDS - 1 - w] = parseHex(word);
	}

	return c;
}

Mode Mode::reverse(const std::string strPublicAddress, const int steps, const bool extented, const bool cache, const int skipX, const int skipY, const bool single) {
	Mode r;
	r.name = "reverse";
	r.kernel = "profanity_score_reverse";

	assert(strPublicAddress.size() == 130);
	r.targetAddress.x = parseCoordinate(strPublicAddress.substr(2, 64));
	r.targetAddress.y = parseCoordinate(strPublicAddress.substr(66, 64));
	r.steps = steps;
	r.extended = extented;
	r.cache = cache;
	r.skipX = skipX;
	r.skipY = skipY;
	r.single = single;

	return r;
}

Mode Mode::hashTable(const bool extented, const int skipY) {
	Mode r;
	r.name = "hashTable";
	r.kernel = "profanity_score_reverse";
	r.extended = extented;
	r.cache = false;
	r.skipX = 0;
	r.skipY = skipY;
	r.single = false;

	return r;
}

Mode Mode::matching(const std::string strHex) {
	Mode r;
	r.name = "matching";
	r.kernel = "profanity_score_matching";

	std::fill( r.data1, r.data1 + sizeof(r.data1), cl_uchar(0) );
	std::fill( r.data2, r.data2 + sizeof(r.data2), cl_uchar(0) );

	auto index = 0;
	
	for( size_t i = 0; i < strHex.size(); i += 2 ) {
		const auto indexHi = hexValueNoException(strHex[i]);
		const auto indexLo = i + 1 < strHex.size() ? hexValueNoException(strHex[i+1]) : std::string::npos;

		const auto valHi = (indexHi == std::string::npos) ? 0 : indexHi << 4;
		const auto valLo = (indexLo == std::string::npos) ? 0 : indexLo;

		const auto maskHi = (indexHi == std::string::npos) ? 0 : 0xF << 4;
		const auto maskLo = (indexLo == std::string::npos) ? 0 : 0xF;

		r.data1[index] = maskHi | maskLo;
		r.data2[index] = valHi | valLo;

		++index;
	}

	return r;
}

Mode Mode::leading(const char charLeading) {

	Mode r;
	r.name = "leading";
	r.kernel = "profanity_score_leading";
	r.data1[0] = static_cast<cl_uchar>(hexValue(charLeading));
	return r;
}

Mode Mode::range(const cl_uchar min, const cl_uchar max) {
	Mode r;
	r.name = "range";
	r.kernel = "profanity_score_range";
	r.data1[0] = min;
	r.data2[0] = max;
	return r;
}

Mode Mode::letters() {
	Mode r = range(10, 15);
	r.name = "letters";
	return r;
}

Mode Mode::numbers() {
	Mode r = range(0, 9);
	r.name = "numbers";
	return r;
}

std::string Mode::transformKernel() const {
	switch (this->target) {
		case ADDRESS:
			return "";
		case CONTRACT:
			return "profanity_transform_contract";
		default:
			throw "No kernel for target";
	}
}

std::string Mode::transformName() const {
	switch (this->target) {
		case ADDRESS:
			return "Address";
		case CONTRACT:
			return "Contract";
		default:
			throw "No name for target";
	}
}

Mode Mode::leadingRange(const cl_uchar min, const cl_uchar max) {
	Mode r;
	r.name = "leadingrange";
	r.kernel = "profanity_score_leadingrange";
	r.data1[0] = min;
	r.data2[0] = max;
	return r;
}

Mode Mode::mirror() {
	Mode r;
	r.name = "mirror";
	r.kernel = "profanity_score_mirror";
	return r;
}

Mode Mode::doubles() {
	Mode r;
	r.name = "doubles";
	r.kernel = "profanity_score_doubles";
	return r;
}