lukechilds
/
lightning
mirror of https://github.com/lukechilds/lightning.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

bitcoin/pullpush.[ch]: expose bitcoin-style marshal/unmarshal. 

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ppa-0.6.1
Rusty Russell 9 years ago
parent
ec3344ce6e
commit
809caa8588
7 changed files with 180 additions and 142 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      Makefile
  2. 1
      bitcoin/block.c
  3. 97
      bitcoin/pullpush.c
  4. 22
      bitcoin/pullpush.h
  5. 1
      bitcoin/test/run-tx-encode.c
  6. 196
      bitcoin/tx.c
  7. 3
      bitcoin/tx.h

2
Makefile
View File

@ -32,6 +32,7 @@ BITCOIN_SRC := \
bitcoin/block.c \
bitcoin/locktime.c \
bitcoin/pubkey.c \
bitcoin/pullpush.c \
bitcoin/script.c \
bitcoin/shadouble.c \
bitcoin/signature.c \
@ -143,6 +144,7 @@ BITCOIN_HEADERS := bitcoin/address.h \
bitcoin/locktime.h \
bitcoin/privkey.h \
bitcoin/pubkey.h \
bitcoin/pullpush.h \
bitcoin/script.h \
bitcoin/shadouble.h \
bitcoin/signature.h \

1
bitcoin/block.c
View File

@ -1,4 +1,5 @@
#include "bitcoin/block.h"
#include "bitcoin/pullpush.h"
#include "bitcoin/tx.h"
#include <ccan/str/hex/hex.h>

97
bitcoin/pullpush.c
View File

@ -0,0 +1,97 @@
#include "pullpush.h"
#include "varint.h"
#include <ccan/endian/endian.h>
#include <ccan/mem/mem.h>
#include <ccan/tal/tal.h>
void push_varint(varint_t v,
void (*push)(const void *, size_t, void *), void *pushp)
{
u8 buf[VARINT_MAX_LEN];
push(buf, varint_put(buf, v), pushp);
}
void push_le32(u32 v,
void (*push)(const void *, size_t, void *), void *pushp)
{
le32 l = cpu_to_le32(v);
push(&l, sizeof(l), pushp);
}
void push_le64(u64 v,
void (*push)(const void *, size_t, void *), void *pushp)
{
le64 l = cpu_to_le64(v);
push(&l, sizeof(l), pushp);
}
void push_varint_blob(const void *blob, varint_t len,
void (*push)(const void *, size_t, void *),
void *pushp)
{
push_varint(len, push, pushp);
push(blob, len, pushp);
}
void push(const void *data, size_t len, void *pptr_)
{
u8 **pptr = pptr_;
size_t oldsize = tal_count(*pptr);
tal_resize(pptr, oldsize + len);
memcpy(*pptr + oldsize, memcheck(data, len), len);
}
/* Sets *cursor to NULL and returns NULL when a pull fails. */
const u8 *pull(const u8 **cursor, size_t *max, void *copy, size_t n)
{
const u8 *p = *cursor;
if (*max < n) {
*cursor = NULL;
*max = 0;
/* Just make sure we don't leak uninitialized mem! */
if (copy)
memset(copy, 0, n);
return NULL;
}
*cursor += n;
*max -= n;
if (copy)
memcpy(copy, p, n);
return memcheck(p, n);
}
u64 pull_varint(const u8 **cursor, size_t *max)
{
u64 ret;
size_t len;
len = varint_get(*cursor, *max, &ret);
if (len == 0) {
*cursor = NULL;
*max = 0;
return 0;
}
pull(cursor, max, NULL, len);
return ret;
}
u32 pull_le32(const u8 **cursor, size_t *max)
{
le32 ret;
if (!pull(cursor, max, &ret, sizeof(ret)))
return 0;
return le32_to_cpu(ret);
}
u64 pull_le64(const u8 **cursor, size_t *max)
{
le64 ret;
if (!pull(cursor, max, &ret, sizeof(ret)))
return 0;
return le64_to_cpu(ret);
}

22
bitcoin/pullpush.h
View File

@ -0,0 +1,22 @@
#ifndef LIGHTNING_BITCOIN_PULLPUSH_H
#define LIGHTNING_BITCOIN_PULLPUSH_H
#include "config.h"
#include "bitcoin/varint.h"
void push_varint(varint_t v,
void (*push)(const void *, size_t, void *), void *pushp);
void push_le32(u32 v, void (*push)(const void *, size_t, void *), void *pushp);
void push_le64(u64 v, void (*push)(const void *, size_t, void *), void *pushp);
void push_varint_blob(const void *blob, varint_t len,
void (*push)(const void *, size_t, void *),
void *pushp);
u64 pull_varint(const u8 **cursor, size_t *max);
u32 pull_le32(const u8 **cursor, size_t *max);
u64 pull_le64(const u8 **cursor, size_t *max);
/* This extends **pptr by tal_resize */
void push(const void *data, size_t len, void *pptr_);
const u8 *pull(const u8 **cursor, size_t *max, void *copy, size_t n);
#endif /* LIGHTNING_BITCOIN_PULLPUSH_H */

1
bitcoin/test/run-tx-encode.c
View File

@ -1,3 +1,4 @@
#include "bitcoin/pullpush.c"
#include "bitcoin/tx.c"
#include "bitcoin/shadouble.c"
#include "bitcoin/varint.c"

196
bitcoin/tx.c
View File

@ -1,5 +1,6 @@
#include "bitcoin/block.h"
#include "tx.h"
#include "bitcoin/pullpush.h"
#include "bitcoin/tx.h"
#include <assert.h>
#include <ccan/cast/cast.h>
#include <ccan/crypto/sha256/sha256.h>
@ -11,59 +12,29 @@
#define SEGREGATED_WITNESS_FLAG 0x1
static void add_varint(varint_t v,
void (*add)(const void *, size_t, void *), void *addp)
static void push_tx_input(const struct bitcoin_tx_input *input,
void (*push)(const void *, size_t, void *), void *pushp)
{
u8 buf[VARINT_MAX_LEN];
add(buf, varint_put(buf, v), addp);
}
static void add_le32(u32 v,
void (*add)(const void *, size_t, void *), void *addp)
{
le32 l = cpu_to_le32(v);
add(&l, sizeof(l), addp);
}
static void add_le64(u64 v,
void (*add)(const void *, size_t, void *), void *addp)
{
le64 l = cpu_to_le64(v);
add(&l, sizeof(l), addp);
}
static void add_varint_blob(const void *blob, varint_t len,
void (*add)(const void *, size_t, void *),
void *addp)
{
add_varint(len, add, addp);
add(blob, len, addp);
push(&input->txid, sizeof(input->txid), pushp);
push_le32(input->index, push, pushp);
push_varint_blob(input->script, input->script_length, push, pushp);
push_le32(input->sequence_number, push, pushp);
}
static void add_tx_input(const struct bitcoin_tx_input *input,
void (*add)(const void *, size_t, void *), void *addp)
static void push_tx_output(const struct bitcoin_tx_output *output,
void (*push)(const void *, size_t, void *), void *pushp)
{
add(&input->txid, sizeof(input->txid), addp);
add_le32(input->index, add, addp);
add_varint_blob(input->script, input->script_length, add, addp);
add_le32(input->sequence_number, add, addp);
}
static void add_tx_output(const struct bitcoin_tx_output *output,
void (*add)(const void *, size_t, void *), void *addp)
{
add_le64(output->amount, add, addp);
add_varint_blob(output->script, output->script_length, add, addp);
push_le64(output->amount, push, pushp);
push_varint_blob(output->script, output->script_length, push, pushp);
}
/* BIP 141:
* It is followed by stack items, with each item starts with a var_int
* to indicate the length. */
static void add_witness(const u8 *witness,
void (*add)(const void *, size_t, void *), void *addp)
static void push_witness(const u8 *witness,
void (*push)(const void *, size_t, void *), void *pushp)
{
add_varint_blob(witness, tal_count(witness), add, addp);
push_varint_blob(witness, tal_count(witness), push, pushp);
}
/* BIP144:
@ -83,8 +54,8 @@ static bool uses_witness(const struct bitcoin_tx *tx)
* transaction. Each txin is associated with a witness field. A
* witness field starts with a var_int to indicate the number of stack
* items for the txin. */
static void add_witnesses(const struct bitcoin_tx *tx,
void (*add)(const void *, size_t, void *), void *addp)
static void push_witnesses(const struct bitcoin_tx *tx,
void (*push)(const void *, size_t, void *), void *pushp)
{
size_t i;
for (i = 0; i < tx->input_count; i++) {
@ -92,28 +63,28 @@ static void add_witnesses(const struct bitcoin_tx *tx,
/* Not every input needs a witness. */
if (!tx->input[i].witness) {
add_varint(0, add, addp);
push_varint(0, push, pushp);
continue;
}
elements = tal_count(tx->input[i].witness);
add_varint(elements, add, addp);
push_varint(elements, push, pushp);
for (j = 0;
j < tal_count(tx->input[i].witness);
j++) {
add_witness(tx->input[i].witness[j],
add, addp);
push_witness(tx->input[i].witness[j],
push, pushp);
}
}
}
static void add_tx(const struct bitcoin_tx *tx,
void (*add)(const void *, size_t, void *), void *addp,
static void push_tx(const struct bitcoin_tx *tx,
void (*push)(const void *, size_t, void *), void *pushp,
bool extended)
{
varint_t i;
u8 flag = 0;
add_le32(tx->version, add, addp);
push_le32(tx->version, push, pushp);
if (extended) {
u8 marker;
@ -121,7 +92,7 @@ static void add_tx(const struct bitcoin_tx *tx,
/* marker char Must be zero */
/* flag char Must be nonzero */
marker = 0;
add(&marker, 1, addp);
push(&marker, 1, pushp);
/* BIP 141: The flag MUST be a 1-byte non-zero
* value. Currently, 0x01 MUST be used.
*
@ -131,24 +102,24 @@ static void add_tx(const struct bitcoin_tx *tx,
* witness. */
if (uses_witness(tx))
flag = SEGREGATED_WITNESS_FLAG;
add(&flag, 1, addp);
push(&flag, 1, pushp);
}
add_varint(tx->input_count, add, addp);
push_varint(tx->input_count, push, pushp);
for (i = 0; i < tx->input_count; i++)
add_tx_input(&tx->input[i], add, addp);
push_tx_input(&tx->input[i], push, pushp);
add_varint(tx->output_count, add, addp);
push_varint(tx->output_count, push, pushp);
for (i = 0; i < tx->output_count; i++)
add_tx_output(&tx->output[i], add, addp);
push_tx_output(&tx->output[i], push, pushp);
if (flag & SEGREGATED_WITNESS_FLAG)
add_witnesses(tx, add, addp);
push_witnesses(tx, push, pushp);
add_le32(tx->lock_time, add, addp);
push_le32(tx->lock_time, push, pushp);
}
static void add_sha(const void *data, size_t len, void *shactx_)
static void push_sha(const void *data, size_t len, void *shactx_)
{
struct sha256_ctx *ctx = shactx_;
sha256_update(ctx, memcheck(data, len), len);
@ -164,8 +135,8 @@ static void hash_prevouts(struct sha256_double *h, const struct bitcoin_tx *tx)
* outpoints */
sha256_init(&ctx);
for (i = 0; i < tx->input_count; i++) {
add_sha(&tx->input[i].txid, sizeof(tx->input[i].txid), &ctx);
add_le32(tx->input[i].index, add_sha, &ctx);
push_sha(&tx->input[i].txid, sizeof(tx->input[i].txid), &ctx);
push_le32(tx->input[i].index, push_sha, &ctx);
}
sha256_double_done(&ctx, h);
}
@ -180,7 +151,7 @@ static void hash_sequence(struct sha256_double *h, const struct bitcoin_tx *tx)
* of nSequence of all inputs */
sha256_init(&ctx);
for (i = 0; i < tx->input_count; i++)
add_le32(tx->input[i].sequence_number, add_sha, &ctx);
push_le32(tx->input[i].sequence_number, push_sha, &ctx);
sha256_double_done(&ctx, h);
}
@ -196,10 +167,10 @@ static void hash_outputs(struct sha256_double *h, const struct bitcoin_tx *tx)
sha256_init(&ctx);
for (i = 0; i < tx->output_count; i++) {
add_le64(tx->output[i].amount, add_sha, &ctx);
add_varint_blob(tx->output[i].script,
push_le64(tx->output[i].amount, push_sha, &ctx);
push_varint_blob(tx->output[i].script,
tx->output[i].script_length,
add_sha, &ctx);
push_sha, &ctx);
}
sha256_double_done(&ctx, h);
@ -217,36 +188,36 @@ static void hash_for_segwit(struct sha256_ctx *ctx,
* Double SHA256 of the serialization of:
* 1. nVersion of the transaction (4-byte little endian)
*/
add_le32(tx->version, add_sha, ctx);
push_le32(tx->version, push_sha, ctx);
/* 2. hashPrevouts (32-byte hash) */
hash_prevouts(&h, tx);
add_sha(&h, sizeof(h), ctx);
push_sha(&h, sizeof(h), ctx);
/* 3. hashSequence (32-byte hash) */
hash_sequence(&h, tx);
add_sha(&h, sizeof(h), ctx);
push_sha(&h, sizeof(h), ctx);
/* 4. outpoint (32-byte hash + 4-byte little endian) */
add_sha(&tx->input[input_num].txid, sizeof(tx->input[input_num].txid),
push_sha(&tx->input[input_num].txid, sizeof(tx->input[input_num].txid),
ctx);
add_le32(tx->input[input_num].index, add_sha, ctx);
push_le32(tx->input[input_num].index, push_sha, ctx);
/* 5. scriptCode of the input (varInt for the length + script) */
add_varint_blob(witness_script, tal_count(witness_script), add_sha, ctx);
push_varint_blob(witness_script, tal_count(witness_script), push_sha, ctx);
/* 6. value of the output spent by this input (8-byte little end) */
add_le64(*tx->input[input_num].amount, add_sha, ctx);
push_le64(*tx->input[input_num].amount, push_sha, ctx);
/* 7. nSequence of the input (4-byte little endian) */
add_le32(tx->input[input_num].sequence_number, add_sha, ctx);
push_le32(tx->input[input_num].sequence_number, push_sha, ctx);
/* 8. hashOutputs (32-byte hash) */
hash_outputs(&h, tx);
add_sha(&h, sizeof(h), ctx);
push_sha(&h, sizeof(h), ctx);
/* 9. nLocktime of the transaction (4-byte little endian) */
add_le32(tx->lock_time, add_sha, ctx);
push_le32(tx->lock_time, push_sha, ctx);
}
void sha256_tx_for_sig(struct sha256_double *h, const struct bitcoin_tx *tx,
@ -270,14 +241,14 @@ void sha256_tx_for_sig(struct sha256_double *h, const struct bitcoin_tx *tx,
hash_for_segwit(&ctx, tx, input_num, witness_script);
} else {
/* Otherwise signature hashing never includes witness. */
add_tx(tx, add_sha, &ctx, false);
push_tx(tx, push_sha, &ctx, false);
}
sha256_le32(&ctx, stype);
sha256_double_done(&ctx, h);
}
static void add_linearize(const void *data, size_t len, void *pptr_)
static void push_linearize(const void *data, size_t len, void *pptr_)
{
u8 **pptr = pptr_;
size_t oldsize = tal_count(*pptr);
@ -289,11 +260,11 @@ static void add_linearize(const void *data, size_t len, void *pptr_)
u8 *linearize_tx(const tal_t *ctx, const struct bitcoin_tx *tx)
{
u8 *arr = tal_arr(ctx, u8, 0);
add_tx(tx, add_linearize, &arr, uses_witness(tx));
push_tx(tx, push_linearize, &arr, uses_witness(tx));
return arr;
}
static void add_measure(const void *data, size_t len, void *lenp)
static void push_measure(const void *data, size_t len, void *lenp)
{
*(size_t *)lenp += len;
}
@ -301,11 +272,11 @@ static void add_measure(const void *data, size_t len, void *lenp)
size_t measure_tx_cost(const struct bitcoin_tx *tx)
{
size_t non_witness_len = 0, witness_len = 0;
add_tx(tx, add_measure, &non_witness_len, false);
push_tx(tx, push_measure, &non_witness_len, false);
if (uses_witness(tx))
add_witnesses(tx, add_measure, &witness_len);
push_witnesses(tx, push_measure, &witness_len);
/* Witness bytes only add 1/4 of normal bytes, for cost. */
/* Witness bytes only push 1/4 of normal bytes, for cost. */
return non_witness_len * 4 + witness_len;
}
@ -314,7 +285,7 @@ void bitcoin_txid(const struct bitcoin_tx *tx, struct sha256_double *txid)
struct sha256_ctx ctx = SHA256_INIT;
/* For TXID, we never use extended form. */
add_tx(tx, add_sha, &ctx, false);
push_tx(tx, push_sha, &ctx, false);
sha256_double_done(&ctx, txid);
}
@ -344,59 +315,6 @@ struct bitcoin_tx *bitcoin_tx(const tal_t *ctx, varint_t input_count,
return tx;
}
/* Sets *cursor to NULL and returns NULL when a pull fails. */
const u8 *pull(const u8 **cursor, size_t *max, void *copy, size_t n)
{
const u8 *p = *cursor;
if (*max < n) {
*cursor = NULL;
*max = 0;
/* Just make sure we don't leak uninitialized mem! */
if (copy)
memset(copy, 0, n);
return NULL;
}
*cursor += n;
*max -= n;
if (copy)
memcpy(copy, p, n);
return memcheck(p, n);
}
u64 pull_varint(const u8 **cursor, size_t *max)
{
u64 ret;
size_t len;
len = varint_get(*cursor, *max, &ret);
if (len == 0) {
*cursor = NULL;
*max = 0;
return 0;
}
pull(cursor, max, NULL, len);
return ret;
}
static u32 pull_le32(const u8 **cursor, size_t *max)
{
le32 ret;
if (!pull(cursor, max, &ret, sizeof(ret)))
return 0;
return le32_to_cpu(ret);
}
static u64 pull_le64(const u8 **cursor, size_t *max)
{
le64 ret;
if (!pull(cursor, max, &ret, sizeof(ret)))
return 0;
return le64_to_cpu(ret);
}
static bool pull_sha256_double(const u8 **cursor, size_t *max,
struct sha256_double *h)
{

3
bitcoin/tx.h
View File

@ -69,11 +69,8 @@ bool bitcoin_txid_from_hex(const char *hexstr, size_t hexstr_len,
bool bitcoin_txid_to_hex(const struct sha256_double *txid,
char *hexstr, size_t hexstr_len);
/* Internal de-linearization functions. */
struct bitcoin_tx *pull_bitcoin_tx(const tal_t *ctx,
const u8 **cursor, size_t *max);
u64 pull_varint(const u8 **cursor, size_t *max);
const u8 *pull(const u8 **cursor, size_t *max, void *copy, size_t n);
#endif /* LIGHTNING_BITCOIN_TX_H */

Write Preview
Loading…
Cancel
Save