static void output_data_hex(void)
{
size_t alloc_len = opt_hexdata ? strlen(opt_hexdata) : 512;
cstring *s = cstr_new_sz(alloc_len);
ser_bp_tx(s, &tx);
char hexstr[(s->len * 2) + 1];
encode_hex(hexstr, s->str, s->len);
printf("%s\n", hexstr);
cstr_free(s, true);
}
static void bp_tx_calc_sighash(bu256_t *hash, const struct bp_tx *tx,
int nHashType)
{
/* TODO: introduce hashing-only serialization mode */
GString *s = g_string_sized_new(512);
ser_bp_tx(s, tx);
ser_s32(s, nHashType);
bu_Hash((unsigned char *) hash, s->str, s->len);
g_string_free(s, TRUE);
}
static void runtest(const char *json_fn_base, const char *ser_fn_base)
{
char *fn = test_filename(json_fn_base);
json_t *meta = read_json(fn);
assert(json_is_object(meta));
char *ser_fn = test_filename(ser_fn_base);
void *data = NULL;
size_t data_len = 0;
bool rc = bu_read_file(ser_fn, &data, &data_len, 100 * 1024 * 1024);
assert(rc);
const char *hashstr = json_string_value(json_object_get(meta, "hash"));
assert(hashstr != NULL);
unsigned int size = json_integer_value(json_object_get(meta, "size"));
assert(data_len == size);
struct bp_tx tx;
bp_tx_init(&tx);
struct const_buffer buf = { data, data_len };
rc = deser_bp_tx(&tx, &buf);
assert(rc);
cstring *gs = cstr_new_sz(10000);
ser_bp_tx(gs, &tx);
if (gs->len != data_len) {
fprintf(stderr, "gs->len %ld, data_len %lu\n",
(long)gs->len, data_len);
assert(gs->len == data_len);
}
assert(memcmp(gs->str, data, data_len) == 0);
bp_tx_calc_sha256(&tx);
char hexstr[BU256_STRSZ];
bu256_hex(hexstr, &tx.sha256);
if (strcmp(hexstr, hashstr)) {
fprintf(stderr, "tx: wanted hash %s,\n got hash %s\n",
hashstr, hexstr);
assert(!strcmp(hexstr, hashstr));
}
assert(tx.vin->len == 1);
assert(tx.vout->len == 2);
struct bp_tx tx_copy;
bp_tx_init(&tx_copy);
bp_tx_copy(&tx_copy, &tx);
bp_tx_calc_sha256(&tx_copy);
assert(bu256_equal(&tx_copy.sha256, &tx.sha256) == true);
bp_tx_free(&tx);
bp_tx_free(&tx_copy);
cstr_free(gs, true);
free(data);
free(fn);
free(ser_fn);
json_decref(meta);
}
