static void test_extended_key()
{
printf("TEST: test_extended_key\n");
// Check we get sensible results when parsing some test vector data
struct hd_extended_key pub;
assert(hd_extended_key_init(&pub));
{
cstring *tv1data = base58_decode(s_tv1_m_xpub);
assert(hd_extended_key_deser(&pub, tv1data->str, tv1data->len));
cstr_free(tv1data, true);
}
struct hd_extended_key priv;
assert(hd_extended_key_init(&priv));
{
cstring *tv1data = base58_decode(s_tv1_m_xprv);
assert(hd_extended_key_deser(&priv, tv1data->str, tv1data->len));
cstr_free(tv1data, true);
}
printf("PUB:\n");
print_ek_public(&pub);
printf("PRV:\n");
print_ek_public(&priv);
// Check we get the same codechains
assert(0 == memcmp(pub.chaincode.data, priv.chaincode.data, 32));
hd_extended_key_free(&priv);
hd_extended_key_free(&pub);
}
bool coind_validate_address(YAAMP_COIND *coind)
{
if(!coind->wallet[0]) return false;
char params[YAAMP_SMALLBUFSIZE];
sprintf(params, "[\"%s\"]", coind->wallet);
json_value *json = rpc_call(&coind->rpc, "validateaddress", params);
if(!json) return false;
json_value *json_result = json_get_object(json, "result");
if(!json_result)
{
json_value_free(json);
return false;
}
bool isvalid = json_get_bool(json_result, "isvalid");
if(!isvalid) stratumlog("%s wallet %s is not valid.\n", coind->name, coind->wallet);
bool ismine = json_get_bool(json_result, "ismine");
if(!ismine) stratumlog("%s wallet %s is not mine.\n", coind->name, coind->wallet);
const char *p = json_get_string(json_result, "pubkey");
if(p) strcpy(coind->pubkey, p);
json_value_free(json);
base58_decode(coind->wallet, coind->script_pubkey);
return isvalid && ismine;
}
static void test_decode(const char *hexstr, const char *base58_str)
{
size_t hs_len = strlen(hexstr) / 2;
unsigned char *raw = calloc(1, hs_len);
size_t out_len;
bool rc = decode_hex(raw, hs_len, hexstr, &out_len);
if (!rc) {
fprintf(stderr, "raw %p, sizeof(raw) %lu, hexstr %p %s\n",
raw, hs_len, hexstr, hexstr);
assert(rc);
}
cstring *s = base58_decode(base58_str);
if (memcmp(s->str, raw, out_len < s->len ? out_len : s->len)) {
dumphex("decode have", s->str, s->len);
dumphex("decode want", raw, out_len);
assert(memcmp(s->str, raw, out_len) == 0);
}
if (s->len != out_len) {
fprintf(stderr, "decode len: have %u, want %u\n",
(unsigned int) s->len,
(unsigned int) out_len);
dumphex("decode have", s->str, s->len);
dumphex("decode want", raw, out_len);
assert(s->len == out_len);
}
free(raw);
cstr_free(s, true);
}
cstring *base58_decode_check(unsigned char *addrtype, const char *s_in)
{
/* decode base58 string */
cstring *s = base58_decode(s_in);
if (!s)
return NULL;
if (s->len < 4)
goto err_out;
/* validate with trailing hash, then remove hash */
unsigned char md32[4];
bu_Hash4(md32, s->str, s->len - 4);
if (memcmp(md32, &s->str[s->len - 4], 4))
goto err_out;
cstr_resize(s, s->len - 4);
/* if addrtype requested, remove from front of data string */
if (addrtype) {
*addrtype = (unsigned char) s->str[0];
cstr_erase(s, 0, 1);
}
return s;
err_out:
cstr_free(s, true);
return NULL;
}
static void print_from_base58(const char *str)
{
cstring *out_str = base58_decode(str);
/* *out= out_str->str; */
/* *out_len = out_str->len; */
print_n(out_str->str, out_str->len);
cstr_free(out_str, true);
}
CoinKey::CoinKey(const std::string& src)
{
binary bin = base58_decode(src.c_str());
if (bin.size() == sizeof(m_data))
{
memcpy(&m_data, &bin[0], bin.size());
}
else
{
memset(&m_data, 0, sizeof(m_data));
}
}
static bool read_ek_ser_from_base58(const char *base58,
struct hd_extended_key_serialized *out)
{
cstring *str = base58_decode(base58);
if (str->len == 82) {
memcpy(out->data, str->str, 78);
cstr_free(str, true);
return true;
}
cstr_free(str, true);
return false;
}
static void print_from_base58_key(const char *str)
{
cstring *out_str = base58_decode(str);
/* *out= out_str->str; */
/* *out_len = out_str->len; */
uint8_t *d = (uint8_t *)(out_str->str);
print_n(d, 4); SPACE; // version
print_n(d + 4, 1); SPACE; // depth
print_n(d + 5, 4); SPACE; // parent fingerprint
print_n(d + 9, 4); SPACE; // idx
print_n(d + 13, 32); SPACE; // chain code
print_n(d + 45, 33); SPACE; // key
/* print_n(out_str->str, out_str->len); */
cstr_free(out_str, true);
}
static mrb_value mrb_base58_decode(mrb_state *mrb, mrb_value self)
{
const char *chars = default_chars;
char *custom_chars;
char *data;
mrb_int data_len;
mrb_value result;
mrb_int result_len = 0;
if (mrb_get_args(mrb, "s|z", &data, &data_len, &custom_chars) == 2) {
if (strlen(custom_chars) != 58) mrb_raise(mrb, E_ARGUMENT_ERROR, "Base58 requires 58 symbols");
chars = custom_chars;
}
result = mrb_str_buf_new(mrb, data_len);
result_len = base58_decode(mrb, RSTRING_PTR(result), data, data_len, chars);
if (result_len < 0) mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid Base58 symbol");
return mrb_str_resize(mrb, result, result_len);
}
void coinbase_create(YAAMP_COIND *coind, YAAMP_JOB_TEMPLATE *templ, json_value *json_result)
{
char eheight[64];
ser_number(templ->height, eheight);
char etime[64];
ser_number(time(NULL), etime);
char entime[64];
memset(entime, 0, 64);
if(coind->pos)
ser_string_be(templ->ntime, entime, 1);
char eversion1[64] = "01000000";
if(coind->txmessage)
strcpy(eversion1, "02000000");
char script1[4*1024];
sprintf(script1, "%s%s%s08", eheight, templ->flags, etime);
char script2[4*1024] = "7961616d702e636f6d00"; // yaamp.com
if(!coind->pos && !coind->isaux && templ->auxs_size)
coinbase_aux(templ, script2);
int script_len = strlen(script1)/2 + strlen(script2)/2 + 8;
sprintf(templ->coinb1,
"%s%s010000000000000000000000000000000000000000000000000000000000000000ffffffff%02x%s", // 8+8+74+2 -> height
eversion1, entime, script_len, script1);
sprintf(templ->coinb2, "%s00000000", script2);
json_int_t available = templ->value;
if(strcmp(coind->symbol, "DRK") == 0 || strcmp(coind->symbol, "DASH") == 0 || strcmp(coind->symbol, "BOD") == 0)
// if(strcmp(coind->symbol, "DRK") == 0)
{
char charity_payee[1024] = "";
strcpy(charity_payee, json_get_string(json_result, "payee"));
json_int_t charity_amount = json_get_int(json_result, "payee_amount");
bool charity_payments = json_get_bool(json_result, "masternode_payments");
bool charity_enforce = json_get_bool(json_result, "enforce_masternode_payments");
if(charity_payments && charity_enforce)
{
strcat(templ->coinb2, "02");
available -= charity_amount;
char script_payee[1024];
base58_decode(charity_payee, script_payee);
job_pack_tx(coind, templ->coinb2, charity_amount, script_payee);
}
else
strcat(templ->coinb2, "01");
}
else
strcat(templ->coinb2, "01");
job_pack_tx(coind, templ->coinb2, available, NULL);
strcat(templ->coinb2, "00000000"); // locktime
coind->reward = (double)available/100000000*coind->reward_mul;
// debuglog("coinbase %f\n", coind->reward);
// debuglog("new job: %x, %s, %s, %s\n", coind->templ->id, coind->templ->version, coind->templ->nbits, coind->templ->ntime);
// debuglog("coinb1 %s\n", templ->coinb1);
// debuglog("coinb2 %s\n", templ->coinb2);
}
