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

Remove Alpha support. 

I had already disabled it, and this clears the decks for Segregated Witness
which gives us everything we want.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ppa-0.6.1
Rusty Russell 9 years ago
parent
0f35441a29
commit
8104886503
12 changed files with 48 additions and 342 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 18
      Makefile
  2. 9
      bitcoin/script.c
  3. 21
      bitcoin/signature.c
  4. 6
      bitcoin/signature.h
  5. 230
      bitcoin/tx.c
  6. 11
      bitcoin/tx.h
  7. 6
      close_tx.c
  8. 8
      commit_tx.c
  9. 12
      daemon/peer.c
  10. 22
      protobuf_convert.c
  11. 24
      test-cli/scripts/generate-block.sh
  12. 23
      test-cli/scripts/vars.sh

18
Makefile
View File

@ -7,25 +7,13 @@ PROTOCC:=protoc-c
# We use our own internal ccan copy. # We use our own internal ccan copy.
CCANDIR := ccan CCANDIR := ccan
# Alpha has checksequenceverify, segregated witness+input-amount-in-sig+confidentual-transactions, schnorr, checklocktimeverify
ALPHA_FEATURES := \
-DALPHA_TXSTYLE=1 \
-DHAS_BIP68=0 \
-DHAS_CLTV=1 \
-DHAS_CSV=1 \
-DSCRIPTS_USE_DER=0 \
-DUSE_SCHNORR=1
# Bitcoin uses DER for signatures (Add BIP68 & HAS_CSV if it's supported) # Bitcoin uses DER for signatures (Add BIP68 & HAS_CSV if it's supported)
BITCOIN_FEATURES := \ BITCOIN_FEATURES := \
-DALPHA_TXSTYLE=0 \
-DHAS_BIP68=0 \ -DHAS_BIP68=0 \
-DHAS_CLTV=1 \ -DHAS_CLTV=1 \
-DHAS_CSV=0 \ -DHAS_CSV=0 \
-DSCRIPTS_USE_DER=1 \ -DSCRIPTS_USE_DER=1
-DUSE_SCHNORR=0
#FEATURES := $(ALPHA_FEATURES)
FEATURES := $(BITCOIN_FEATURES) FEATURES := $(BITCOIN_FEATURES)
TEST_PROGRAMS := \ TEST_PROGRAMS := \
@ -236,12 +224,12 @@ ccan/ccan/cdump/tools/cdump-enumstr: ccan/ccan/cdump/tools/cdump-enumstr.o $(CDU
gen_state_names.h: state_types.h ccan/ccan/cdump/tools/cdump-enumstr gen_state_names.h: state_types.h ccan/ccan/cdump/tools/cdump-enumstr
ccan/ccan/cdump/tools/cdump-enumstr state_types.h > $@ ccan/ccan/cdump/tools/cdump-enumstr state_types.h > $@
# We build a static libsecpk1, since we need schnorr for alpha # We build a static libsecpk1, since we need ecdh
# (and it's not API stable yet!). # (and it's not API stable yet!).
libsecp256k1.a: secp256k1/libsecp256k1.la libsecp256k1.a: secp256k1/libsecp256k1.la
secp256k1/libsecp256k1.la: secp256k1/libsecp256k1.la:
cd secp256k1 && ./autogen.sh && ./configure --enable-static=yes --enable-shared=no --enable-tests=no --enable-module-schnorr=yes --enable-module-ecdh=yes --libdir=`pwd`/.. cd secp256k1 && ./autogen.sh && ./configure --enable-static=yes --enable-shared=no --enable-tests=no --enable-module-ecdh=yes --libdir=`pwd`/..
$(MAKE) -C secp256k1 install-exec $(MAKE) -C secp256k1 install-exec
lightning.pb-c.c lightning.pb-c.h: lightning.proto lightning.pb-c.c lightning.pb-c.h: lightning.proto

9
bitcoin/script.c
View File

@ -107,8 +107,7 @@ static void add_push_key(u8 **scriptp, const struct pubkey *key)
static void add_push_sig(u8 **scriptp, const struct bitcoin_signature *sig) static void add_push_sig(u8 **scriptp, const struct bitcoin_signature *sig)
{ {
/* Bitcoin wants DER encoding. */ /* Bitcoin wants DER encoding. */
#if SCRIPTS_USE_DER
u8 der[73]; u8 der[73];
secp256k1_context *secpctx = secp256k1_context_create(0); secp256k1_context *secpctx = secp256k1_context_create(0);
size_t len = signature_to_der(secpctx, der, &sig->sig); size_t len = signature_to_der(secpctx, der, &sig->sig);
@ -117,12 +116,6 @@ static void add_push_sig(u8 **scriptp, const struct bitcoin_signature *sig)
der[len++] = sig->stype; der[len++] = sig->stype;
add_push_bytes(scriptp, der, len); add_push_bytes(scriptp, der, len);
secp256k1_context_destroy(secpctx); secp256k1_context_destroy(secpctx);
#else /* Alpha uses raw encoding */
u8 with_sighash[sizeof(sig->sig) + 1];
memcpy(with_sighash, &sig->sig, sizeof(sig->sig));
with_sighash[sizeof(sig->sig)] = sig->stype;
add_push_bytes(scriptp, with_sighash, sizeof(with_sighash));
#endif
} }
/* FIXME: permute? */ /* FIXME: permute? */

21
bitcoin/signature.c
View File

@ -2,9 +2,6 @@
#include "pubkey.h" #include "pubkey.h"
#include "script.h" #include "script.h"
#include "secp256k1.h" #include "secp256k1.h"
#if USE_SCHNORR
#include "secp256k1_schnorr.h"
#endif
#include "shadouble.h" #include "shadouble.h"
#include "signature.h" #include "signature.h"
#include "tx.h" #include "tx.h"
@ -83,17 +80,10 @@ void sign_hash(secp256k1_context *secpctx,
{ {
bool ok; bool ok;
#if USE_SCHNORR
ok = secp256k1_schnorr_sign(secpctx,
s->schnorr,
h->sha.u.u8,
privkey->secret, NULL, NULL);
#else
ok = secp256k1_ecdsa_sign(secpctx, ok = secp256k1_ecdsa_sign(secpctx,
&s->sig, &s->sig,
h->sha.u.u8, h->sha.u.u8,
privkey->secret, NULL, NULL); privkey->secret, NULL, NULL);
#endif
assert(ok); assert(ok);
} }
@ -148,14 +138,9 @@ bool check_signed_hash(secp256k1_context *secpctx,
{ {
int ret; int ret;
#if USE_SCHNORR
ret = secp256k1_schnorr_verify(secpctx, signature->schnorr,
hash->sha.u.u8, &key->pubkey);
#else
ret = secp256k1_ecdsa_verify(secpctx, ret = secp256k1_ecdsa_verify(secpctx,
&signature->sig, &signature->sig,
hash->sha.u.u8, &key->pubkey); hash->sha.u.u8, &key->pubkey);
#endif
return ret == 1; return ret == 1;
} }
@ -205,7 +190,6 @@ bool check_2of2_sig(secp256k1_context *secpctx,
&& check_signed_hash(secpctx, &hash, &sig2->sig, key2); && check_signed_hash(secpctx, &hash, &sig2->sig, key2);
} }
#if USE_SCHNORR == 0
/* Stolen direct from bitcoin/src/script/sign.cpp: /* Stolen direct from bitcoin/src/script/sign.cpp:
// Copyright (c) 2009-2010 Satoshi Nakamoto // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin Core developers // Copyright (c) 2009-2014 The Bitcoin Core developers
@ -289,15 +273,10 @@ size_t signature_to_der(secp256k1_context *secpctx,
assert(IsValidSignatureEncoding(der, len + 1)); assert(IsValidSignatureEncoding(der, len + 1));
return len; return len;
} }
#endif /* USE_SCHNORR */
/* Signature must have low S value. */ /* Signature must have low S value. */
bool sig_valid(const struct signature *sig) bool sig_valid(const struct signature *sig)
{ {
#if USE_SCHNORR
return true;
#else
/* FIXME! Need libsecp support. */ /* FIXME! Need libsecp support. */
return true; return true;
#endif
} }

6
bitcoin/signature.h
View File

@ -14,11 +14,7 @@ enum sighash_type {
/* ECDSA of double SHA256. */ /* ECDSA of double SHA256. */
struct signature { struct signature {
#if USE_SCHNORR
u8 schnorr[64];
#else
secp256k1_ecdsa_signature sig; secp256k1_ecdsa_signature sig;
#endif
}; };
struct sha256_double; struct sha256_double;
@ -63,10 +59,8 @@ bool check_2of2_sig(secp256k1_context *secpctx,
/* Signature must have low S value. */ /* Signature must have low S value. */
bool sig_valid(const struct signature *s); bool sig_valid(const struct signature *s);
#if USE_SCHNORR == 0
/* Give DER encoding of signature: returns length used (<= 72). */ /* Give DER encoding of signature: returns length used (<= 72). */
size_t signature_to_der(secp256k1_context *secpctx, size_t signature_to_der(secp256k1_context *secpctx,
u8 der[72], const struct signature *s); u8 der[72], const struct signature *s);
#endif
#endif /* LIGHTNING_BITCOIN_SIGNATURE_H */ #endif /* LIGHTNING_BITCOIN_SIGNATURE_H */

230
bitcoin/tx.c
View File

@ -9,48 +9,14 @@
#include <stdio.h> #include <stdio.h>
enum styles { enum styles {
/* Add the CT padding stuff to amount. */ /* For making a signature */
TX_AMOUNT_CT_STYLE = 1, SIG_STYLE,
/* Whether to process CT rangeproof and noncecommitment. */ /* linearizing for sendrawtransaction/getrawtransaction. */
TX_AMOUNT_INCLUDE_CT = 2, LINEARIZE_STYLE,
/* Process the txfee field. */ /* For making transaction IDs. */
TX_FEE = 4, TXID_STYLE
/* Process the input script sig. */
TX_INPUT_SCRIPTSIG = 8,
/* Process the amounts for each input. */
TX_INPUT_AMOUNT = 16,
/* Process the same amounts for each input. */
TX_INPUT_AMOUNT_BUGGY = 32,
/* Process hash of rangeproof and noncecommitment in *output* amount,
* instead of rangeproof and noncecommitment themselves. */
TX_OUTPUT_AMOUNT_HASHPROOF = 64
}; };
#if ALPHA_TXSTYLE
/* Linearizing has everything, except input amount (which is implied) */
#define LINEARIZE_STYLE (TX_AMOUNT_CT_STYLE | TX_AMOUNT_INCLUDE_CT | TX_FEE | TX_INPUT_SCRIPTSIG)
/* Alpha txids don't include input scripts, or rangeproof/txcommit in output */
#define TXID_STYLE (TX_AMOUNT_CT_STYLE | TX_FEE)
/* Alpha signatures sign the input script (assuming others are set to
* 0-len), as well as the input fee.
* They sign a hash of the rangeproof and noncecommitment for inputs,
* rather than the non rangeproof and noncecommitment themselves.
*
* For some reason they skip the txfee. */
#define SIG_STYLE (TX_AMOUNT_CT_STYLE | TX_AMOUNT_INCLUDE_CT | TX_INPUT_SCRIPTSIG | TX_INPUT_AMOUNT | TX_INPUT_AMOUNT_BUGGY | TX_OUTPUT_AMOUNT_HASHPROOF)
#else /* BITCOIN */
/* Process all the bitcoin fields. Works for txid, serialization and signing */
#define LINEARIZE_STYLE (TX_INPUT_SCRIPTSIG)
#define TXID_STYLE (TX_INPUT_SCRIPTSIG)
#define SIG_STYLE (TX_INPUT_SCRIPTSIG)
#endif
static void add_varint(varint_t v, static void add_varint(varint_t v,
void (*add)(const void *, size_t, void *), void *addp, void (*add)(const void *, size_t, void *), void *addp,
enum styles style) enum styles style)
@ -99,68 +65,14 @@ static void add_le64(u64 v,
add(&l, sizeof(l), addp); add(&l, sizeof(l), addp);
} }
static void add_value(u64 amount,
void (*add)(const void *, size_t, void *),
void *addp,
bool output,
enum styles style)
{
if (style & TX_AMOUNT_CT_STYLE) {
/* The input is hashed as a 33 byte value (for CT); 25 0, then
* the big-endian value. */
static u8 zeroes[25];
be64 b = cpu_to_be64(amount);
add(zeroes, sizeof(zeroes), addp);
add(&b, sizeof(b), addp);
if (style & TX_AMOUNT_INCLUDE_CT) {
/* Two more zeroes: Rangeproof and Noncecommitment */
if (output && (style & TX_OUTPUT_AMOUNT_HASHPROOF)) {
struct sha256_double h;
sha256_double(&h, zeroes, 2);
add(&h, sizeof(h), addp);
} else {
add_varint(0, add, addp, style);
add_varint(0, add, addp, style);
}
}
} else {
add_le64(amount, add, addp, style);
}
}
static void add_input_value(u64 amount,
void (*add)(const void *, size_t, void *),
void *addp,
enum styles style)
{
return add_value(amount, add, addp, false, style);
}
static void add_output_value(u64 amount,
void (*add)(const void *, size_t, void *),
void *addp,
enum styles style)
{
return add_value(amount, add, addp, true, style);
}
static void add_tx_input(const struct bitcoin_tx_input *input, static void add_tx_input(const struct bitcoin_tx_input *input,
void (*add)(const void *, size_t, void *), void *addp, void (*add)(const void *, size_t, void *), void *addp,
u64 dummy_amount,
enum styles style) enum styles style)
{ {
add(&input->txid, sizeof(input->txid), addp); add(&input->txid, sizeof(input->txid), addp);
add_le32(input->index, add, addp, style); add_le32(input->index, add, addp, style);
if (style & TX_INPUT_AMOUNT) { add_varint(input->script_length, add, addp, style);
if (style & TX_INPUT_AMOUNT_BUGGY) add(input->script, input->script_length, addp);
add_input_value(dummy_amount, add, addp, style);
else
add_input_value(input->input_amount, add, addp, style);
}
if (style & TX_INPUT_SCRIPTSIG) {
add_varint(input->script_length, add, addp, style);
add(input->script, input->script_length, addp);
}
add_le32(input->sequence_number, add, addp, style); add_le32(input->sequence_number, add, addp, style);
} }
@ -168,14 +80,13 @@ static void add_tx_output(const struct bitcoin_tx_output *output,
void (*add)(const void *, size_t, void *), void *addp, void (*add)(const void *, size_t, void *), void *addp,
enum styles style) enum styles style)
{ {
add_output_value(output->amount, add, addp, style); add_le64(output->amount, add, addp, style);
add_varint(output->script_length, add, addp, style); add_varint(output->script_length, add, addp, style);
add(output->script, output->script_length, addp); add(output->script, output->script_length, addp);
} }
static void add_tx(const struct bitcoin_tx *tx, static void add_tx(const struct bitcoin_tx *tx,
void (*add)(const void *, size_t, void *), void *addp, void (*add)(const void *, size_t, void *), void *addp,
u64 dummy_amount,
enum styles style) enum styles style)
{ {
varint_t i; varint_t i;
@ -183,10 +94,7 @@ static void add_tx(const struct bitcoin_tx *tx,
add_le32(tx->version, add, addp, style); add_le32(tx->version, add, addp, style);
add_varint(tx->input_count, add, addp, style); add_varint(tx->input_count, add, addp, style);
for (i = 0; i < tx->input_count; i++) for (i = 0; i < tx->input_count; i++)
add_tx_input(&tx->input[i], add, addp, dummy_amount, style); add_tx_input(&tx->input[i], add, addp, style);
if (style & TX_FEE)
add_le64(tx->fee, add, addp, style);
add_varint(tx->output_count, add, addp, style); add_varint(tx->output_count, add, addp, style);
for (i = 0; i < tx->output_count; i++) for (i = 0; i < tx->output_count; i++)
@ -210,7 +118,7 @@ void sha256_tx_for_sig(struct sha256_ctx *ctx, const struct bitcoin_tx *tx,
for (i = 0; i < tx->input_count; i++) for (i = 0; i < tx->input_count; i++)
if (i != input_num) if (i != input_num)
assert(tx->input[i].script_length == 0); assert(tx->input[i].script_length == 0);
add_tx(tx, add_sha, ctx, tx->input[input_num].input_amount, SIG_STYLE); add_tx(tx, add_sha, ctx, SIG_STYLE);
} }
static void add_linearize(const void *data, size_t len, void *pptr_) static void add_linearize(const void *data, size_t len, void *pptr_)
@ -225,7 +133,7 @@ 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 *linearize_tx(const tal_t *ctx, const struct bitcoin_tx *tx)
{ {
u8 *arr = tal_arr(ctx, u8, 0); u8 *arr = tal_arr(ctx, u8, 0);
add_tx(tx, add_linearize, &arr, 0, LINEARIZE_STYLE); add_tx(tx, add_linearize, &arr, LINEARIZE_STYLE);
return arr; return arr;
} }
@ -233,7 +141,7 @@ void bitcoin_txid(const struct bitcoin_tx *tx, struct sha256_double *txid)
{ {
struct sha256_ctx ctx = SHA256_INIT; struct sha256_ctx ctx = SHA256_INIT;
add_tx(tx, add_sha, &ctx, 0, TXID_STYLE); add_tx(tx, add_sha, &ctx, TXID_STYLE);
sha256_double_done(&ctx, txid); sha256_double_done(&ctx, txid);
} }
@ -343,41 +251,8 @@ static u64 pull_value(const u8 **cursor, size_t *max)
{ {
u64 amount; u64 amount;
if (LINEARIZE_STYLE & TX_AMOUNT_CT_STYLE) { amount = pull_le64(cursor, max);
/* The input is hashed as a 33 byte value (for CT); 25 0, then
* the big-endian value. */
u8 zeroes[25];
be64 b;
if (!pull(cursor, max, zeroes, sizeof(zeroes)))
return 0;
/* We don't handle CT amounts. */
if (zeroes[0] != 0)
goto fail;
if (!pull(cursor, max, &b, sizeof(b)))
return 0;
amount = be64_to_cpu(b);
if (LINEARIZE_STYLE & TX_AMOUNT_INCLUDE_CT) {
varint_t rp, nc;
rp = pull_varint(cursor, max);
nc = pull_varint(cursor, max);
if (rp != 0 || nc != 0)
goto fail;
}
} else {
amount = pull_le64(cursor, max);
}
return amount; return amount;
fail:
/* Simulate EOF */
*cursor = NULL;
*max = 0;
return 0;
} }
static void pull_input(const tal_t *ctx, const u8 **cursor, size_t *max, static void pull_input(const tal_t *ctx, const u8 **cursor, size_t *max,
@ -385,14 +260,9 @@ static void pull_input(const tal_t *ctx, const u8 **cursor, size_t *max,
{ {
pull_sha256_double(cursor, max, &input->txid); pull_sha256_double(cursor, max, &input->txid);
input->index = pull_le32(cursor, max); input->index = pull_le32(cursor, max);
if (LINEARIZE_STYLE & TX_INPUT_AMOUNT) { input->script_length = pull_varint(cursor, max);
input->input_amount = pull_value(cursor, max); input->script = tal_arr(ctx, u8, input->script_length);
} pull(cursor, max, input->script, input->script_length);
if (LINEARIZE_STYLE & TX_INPUT_SCRIPTSIG) {
input->script_length = pull_varint(cursor, max);
input->script = tal_arr(ctx, u8, input->script_length);
pull(cursor, max, input->script, input->script_length);
}
input->sequence_number = pull_le32(cursor, max); input->sequence_number = pull_le32(cursor, max);
} }
@ -417,9 +287,6 @@ static struct bitcoin_tx *pull_bitcoin_tx(const tal_t *ctx,
for (i = 0; i < tx->input_count; i++) for (i = 0; i < tx->input_count; i++)
pull_input(tx, cursor, max, tx->input + i); pull_input(tx, cursor, max, tx->input + i);
if (LINEARIZE_STYLE & TX_FEE)
tx->fee = pull_le64(cursor, max);
tx->output_count = pull_varint(cursor, max); tx->output_count = pull_varint(cursor, max);
tx->output = tal_arr(tx, struct bitcoin_tx_output, tx->output_count); tx->output = tal_arr(tx, struct bitcoin_tx_output, tx->output_count);
for (i = 0; i < tx->output_count; i++) for (i = 0; i < tx->output_count; i++)
@ -441,12 +308,9 @@ struct bitcoin_tx *bitcoin_tx_from_hex(const tal_t *ctx, const char *hex,
struct bitcoin_tx *tx; struct bitcoin_tx *tx;
size_t len; size_t len;
end = memchr(hex, ':', hexlen); end = memchr(hex, '\n', hexlen);
if (!end) { if (!end)
end = cast_const(char *, hex) + hexlen; end = cast_const(char *, hex) + hexlen;
if (hexlen > 0 && hex[hexlen-1] == '\n')
end--;
}
len = hex_data_size(end - hex); len = hex_data_size(end - hex);
p = linear_tx = tal_arr(ctx, u8, len); p = linear_tx = tal_arr(ctx, u8, len);
@ -457,28 +321,9 @@ struct bitcoin_tx *bitcoin_tx_from_hex(const tal_t *ctx, const char *hex,
if (!tx) if (!tx)
goto fail; goto fail;
/* Optional appended [:input-amount]* */ if (end != hex + hexlen && *end != '\n')
for (len = 0; len < tx->input_count; len++) {
if (*end != ':')
break;
tx->input[len].input_amount = 0;
end++;
while (end < hex + hexlen && cisdigit(*end)) {
tx->input[len].input_amount *= 10;
tx->input[len].input_amount += *end - '0';
end++;
}
}
if (len == tx->input_count) {
if (end != hex + hexlen && *end != '\n')
goto fail_free_tx;
} else {
/* Input amounts are compulsory for alpha, to generate sigs */
#if ALPHA_TXSTYLE
goto fail_free_tx; goto fail_free_tx;
#endif
}
tal_free(linear_tx); tal_free(linear_tx);
return tx; return tx;
@ -519,36 +364,3 @@ bool bitcoin_txid_to_hex(const struct sha256_double *txid,
reverse_bytes(rev.sha.u.u8, sizeof(rev.sha.u.u8)); reverse_bytes(rev.sha.u.u8, sizeof(rev.sha.u.u8));
return hex_encode(&rev, sizeof(rev), hexstr, hexstr_len); return hex_encode(&rev, sizeof(rev), hexstr, hexstr_len);
} }
static bool write_input_amounts(int fd, const struct bitcoin_tx *tx)
{
/* Alpha required input amounts, so append them */
#if ALPHA_TXSTYLE
size_t i;
for (i = 0; i < tx->input_count; i++) {
char str[1 + STR_MAX_CHARS(tx->input[i].input_amount)];
sprintf(str, ":%llu",
(unsigned long long)tx->input[i].input_amount);
if (!write_all(fd, str, strlen(str)))
return false;
}
#endif
return true;
}
bool bitcoin_tx_write(int fd, const struct bitcoin_tx *tx)
{
u8 *tx_arr;
char *tx_hex;
bool ok;
tx_arr = linearize_tx(NULL, tx);
tx_hex = tal_arr(tx_arr, char, hex_str_size(tal_count(tx_arr)));
hex_encode(tx_arr, tal_count(tx_arr), tx_hex, tal_count(tx_hex));
ok = write_all(fd, tx_hex, strlen(tx_hex))
&& write_input_amounts(fd, tx);
tal_free(tx_arr);
return ok;
}

11
bitcoin/tx.h
View File

@ -13,9 +13,6 @@ struct bitcoin_tx {
varint_t input_count; varint_t input_count;
struct bitcoin_tx_input *input; struct bitcoin_tx_input *input;
/* Only in alpha. */
u64 fee;
varint_t output_count; varint_t output_count;
struct bitcoin_tx_output *output; struct bitcoin_tx_output *output;
u32 lock_time; u32 lock_time;
@ -28,9 +25,6 @@ struct bitcoin_tx_output {
}; };
struct bitcoin_tx_input { struct bitcoin_tx_input {
/* In alpha, this is hashed for signature */
u64 input_amount;
struct sha256_double txid; struct sha256_double txid;
u32 index; /* output number referred to by above */ u32 index; /* output number referred to by above */
varint_t script_length; varint_t script_length;
@ -54,13 +48,10 @@ u8 *linearize_tx(const tal_t *ctx, const struct bitcoin_tx *tx);
struct bitcoin_tx *bitcoin_tx(const tal_t *ctx, varint_t input_count, struct bitcoin_tx *bitcoin_tx(const tal_t *ctx, varint_t input_count,
varint_t output_count); varint_t output_count);
/* This takes a raw bitcoin tx in hex, with [:<64-bit-satoshi>] appended /* This takes a raw bitcoin tx in hex. */
* for each input (required for -DALPHA). */
struct bitcoin_tx *bitcoin_tx_from_hex(const tal_t *ctx, const char *hex, struct bitcoin_tx *bitcoin_tx_from_hex(const tal_t *ctx, const char *hex,
size_t hexlen); size_t hexlen);
bool bitcoin_tx_write(int fd, const struct bitcoin_tx *tx);
/* Parse hex string to get txid (reversed, a-la bitcoind). */ /* Parse hex string to get txid (reversed, a-la bitcoind). */
bool bitcoin_txid_from_hex(const char *hexstr, size_t hexstr_len, bool bitcoin_txid_from_hex(const char *hexstr, size_t hexstr_len,
struct sha256_double *txid); struct sha256_double *txid);

6
close_tx.c
View File

@ -24,7 +24,6 @@ struct bitcoin_tx *create_close_tx(secp256k1_context *secpctx,
/* Our input spends the anchor tx output. */ /* Our input spends the anchor tx output. */
tx->input[0].txid = *anchor_txid; tx->input[0].txid = *anchor_txid;
tx->input[0].index = anchor_index; tx->input[0].index = anchor_index;
tx->input[0].input_amount = anchor_satoshis;
/* One output is to us. */ /* One output is to us. */
tx->output[0].amount = to_us; tx->output[0].amount = to_us;
@ -38,10 +37,7 @@ struct bitcoin_tx *create_close_tx(secp256k1_context *secpctx,
tx->output[1].script = scriptpubkey_p2sh(tx, redeemscript); tx->output[1].script = scriptpubkey_p2sh(tx, redeemscript);
tx->output[1].script_length = tal_count(tx->output[1].script); tx->output[1].script_length = tal_count(tx->output[1].script);
assert(tx->output[0].amount + tx->output[1].amount assert(tx->output[0].amount + tx->output[1].amount <= anchor_satoshis);
<= tx->input[0].input_amount);
tx->fee = tx->input[0].input_amount
- (tx->output[0].amount + tx->output[1].amount);
permute_outputs(tx->output, 2, NULL); permute_outputs(tx->output, 2, NULL);
return tx; return tx;

8
commit_tx.c
View File

@ -56,7 +56,6 @@ struct bitcoin_tx *create_commit_tx(const tal_t *ctx,
/* Our input spends the anchor tx output. */ /* Our input spends the anchor tx output. */
tx->input[0].txid = *anchor_txid; tx->input[0].txid = *anchor_txid;
tx->input[0].index = anchor_index; tx->input[0].index = anchor_index;
tx->input[0].input_amount = anchor_satoshis;
/* First output is a P2SH to a complex redeem script (usu. for me) */ /* First output is a P2SH to a complex redeem script (usu. for me) */
redeemscript = bitcoin_redeem_secret_or_delay(tx, our_final, redeemscript = bitcoin_redeem_secret_or_delay(tx, our_final,
@ -95,11 +94,8 @@ struct bitcoin_tx *create_commit_tx(const tal_t *ctx,
total += tx->output[num++].amount; total += tx->output[num++].amount;
} }
assert(num == tx->output_count); assert(num == tx->output_count);
assert(total <= anchor_satoshis);
/* Calculate fee; difference of inputs and outputs. */
assert(total <= tx->input[0].input_amount);
tx->fee = tx->input[0].input_amount - total;
permute_outputs(tx->output, tx->output_count, NULL); permute_outputs(tx->output, tx->output_count, NULL);
return tx; return tx;
} }

12
daemon/peer.c
View File

@ -1110,6 +1110,7 @@ const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
struct bitcoin_signature sig; struct bitcoin_signature sig;
struct bitcoin_tx *tx; struct bitcoin_tx *tx;
unsigned int p2sh_out; unsigned int p2sh_out;
uint64_t fee;
/* The redeemscript for a commit tx is fairly complex. */ /* The redeemscript for a commit tx is fairly complex. */
redeemscript = bitcoin_redeem_secret_or_delay(peer, redeemscript = bitcoin_redeem_secret_or_delay(peer,
@ -1123,7 +1124,6 @@ const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
bitcoin_txid(commit, &tx->input[0].txid); bitcoin_txid(commit, &tx->input[0].txid);
p2sh_out = find_p2sh_out(commit, redeemscript); p2sh_out = find_p2sh_out(commit, redeemscript);
tx->input[0].index = p2sh_out; tx->input[0].index = p2sh_out;
tx->input[0].input_amount = commit->output[p2sh_out].amount;
tx->input[0].sequence_number = bitcoin_nsequence(&peer->them.locktime); tx->input[0].sequence_number = bitcoin_nsequence(&peer->them.locktime);
tx->output[0].amount = commit->output[p2sh_out].amount; tx->output[0].amount = commit->output[p2sh_out].amount;
@ -1145,19 +1145,19 @@ const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
/* Now, calculate the fee, given length. */ /* Now, calculate the fee, given length. */
/* FIXME: Dynamic fees! */ /* FIXME: Dynamic fees! */
linear = linearize_tx(peer, tx); linear = linearize_tx(peer, tx);
tx->fee = fee_by_feerate(tal_count(linear), fee = fee_by_feerate(tal_count(linear),
peer->dstate->config.closing_fee_rate); peer->dstate->config.closing_fee_rate);
tal_free(linear); tal_free(linear);
/* FIXME: Fail gracefully in these cases (not worth collecting) */ /* FIXME: Fail gracefully in these cases (not worth collecting) */
if (tx->fee > tx->output[0].amount if (fee > tx->output[0].amount
|| is_dust_amount(tx->output[0].amount - tx->fee)) || is_dust_amount(tx->output[0].amount - fee))
fatal("Amount of %"PRIu64" won't cover fee %"PRIu64, fatal("Amount of %"PRIu64" won't cover fee %"PRIu64,
tx->output[0].amount, tx->fee); tx->output[0].amount, fee);
/* Re-sign with the real values. */ /* Re-sign with the real values. */
tx->input[0].script_length = 0; tx->input[0].script_length = 0;
tx->output[0].amount -= tx->fee; tx->output[0].amount -= fee;
peer_sign_spend(peer, tx, redeemscript, &sig.sig); peer_sign_spend(peer, tx, redeemscript, &sig.sig);
tx->input[0].script = scriptsig_p2sh_secret(tx, NULL, 0, &sig, tx->input[0].script = scriptsig_p2sh_secret(tx, NULL, 0, &sig,

22
protobuf_convert.c
View File

@ -11,16 +11,6 @@ Signature *signature_to_proto(const tal_t *ctx, const struct signature *sig)
assert(sig_valid(sig)); assert(sig_valid(sig));
#if USE_SCHNORR
memcpy(&pb->r1, sig->schnorr, 8);
memcpy(&pb->r2, sig->schnorr + 8, 8);
memcpy(&pb->r3, sig->schnorr + 16, 8);
memcpy(&pb->r4, sig->schnorr + 24, 8);
memcpy(&pb->s1, sig->schnorr + 32, 8);
memcpy(&pb->s2, sig->schnorr + 40, 8);
memcpy(&pb->s3, sig->schnorr + 48, 8);
memcpy(&pb->s4, sig->schnorr + 56, 8);
#else
/* FIXME: Need a portable way to encode signatures in libsecp! */ /* FIXME: Need a portable way to encode signatures in libsecp! */
/* Kill me now... */ /* Kill me now... */
@ -32,7 +22,6 @@ Signature *signature_to_proto(const tal_t *ctx, const struct signature *sig)
memcpy(&pb->s2, sig->sig.data + 40, 8); memcpy(&pb->s2, sig->sig.data + 40, 8);
memcpy(&pb->s3, sig->sig.data + 48, 8); memcpy(&pb->s3, sig->sig.data + 48, 8);
memcpy(&pb->s4, sig->sig.data + 56, 8); memcpy(&pb->s4, sig->sig.data + 56, 8);
#endif
return pb; return pb;
} }
@ -40,16 +29,6 @@ Signature *signature_to_proto(const tal_t *ctx, const struct signature *sig)
bool proto_to_signature(const Signature *pb, struct signature *sig) bool proto_to_signature(const Signature *pb, struct signature *sig)
{ {
/* Kill me again. */ /* Kill me again. */
#if USE_SCHNORR
memcpy(sig->schnorr, &pb->r1, 8);
memcpy(sig->schnorr + 8, &pb->r2, 8);
memcpy(sig->schnorr + 16, &pb->r3, 8);
memcpy(sig->schnorr + 24, &pb->r4, 8);
memcpy(sig->schnorr + 32, &pb->s1, 8);
memcpy(sig->schnorr + 40, &pb->s2, 8);
memcpy(sig->schnorr + 48, &pb->s3, 8);
memcpy(sig->schnorr + 56, &pb->s4, 8);
#else
/* FIXME: Need a portable way to encode signatures in libsecp! */ /* FIXME: Need a portable way to encode signatures in libsecp! */
memcpy(sig->sig.data, &pb->r1, 8); memcpy(sig->sig.data, &pb->r1, 8);
@ -60,7 +39,6 @@ bool proto_to_signature(const Signature *pb, struct signature *sig)
memcpy(sig->sig.data + 40, &pb->s2, 8); memcpy(sig->sig.data + 40, &pb->s2, 8);
memcpy(sig->sig.data + 48, &pb->s3, 8); memcpy(sig->sig.data + 48, &pb->s3, 8);
memcpy(sig->sig.data + 56, &pb->s4, 8); memcpy(sig->sig.data + 56, &pb->s4, 8);
#endif
return sig_valid(sig); return sig_valid(sig);
} }

24
test-cli/scripts/generate-block.sh
View File

@ -6,21 +6,9 @@ set -e
. `dirname $0`/vars.sh . `dirname $0`/vars.sh
INIT=$1 INIT=$1
case $STYLE in # Initially we need 100 blocks so coinbase matures, giving us funds.
alpha) if [ -n "$INIT" ]; then
# This is a one-shot in alpha, it seems. $CLI generate 101
$CLI setgenerate true else
# Avoid median time bug by generating 11 blocks $CLI generate 1
if [ -n "$INIT" ]; then fi
for i in `seq 11`; do $CLI setgenerate true; done
fi
;;
bitcoin)
# Initially we need 100 blocks so coinbase matures, giving us funds.
if [ -n "$INIT" ]; then
$CLI generate 101
else
$CLI generate 1
fi
;;
esac

23
test-cli/scripts/vars.sh
View File

@ -1,23 +1,14 @@
# Sourced by other scripts # Sourced by other scripts
if grep -q ^FEATURES.*ALPHA ../Makefile; then STYLE=bitcoin
STYLE=alpha DATADIR=/tmp/bitcoin-lightning
DATADIR=/tmp/alpha-lightning CLI="bitcoin-cli -datadir=$DATADIR"
REGTESTDIR=alpharegtest REGTESTDIR=regtest
CLI="alpha-cli -datadir=$DATADIR" DAEMON="bitcoind -datadir=$DATADIR"
DAEMON="alphad -datadir=$DATADIR" if grep ^FEATURES ../Makefile | cut -d'#' -f1 | grep -q BIP68; then
SEQ_ENFORCEMENT=true
else
STYLE=bitcoin
DATADIR=/tmp/bitcoin-lightning
CLI="bitcoin-cli -datadir=$DATADIR"
REGTESTDIR=regtest
DAEMON="bitcoind -datadir=$DATADIR"
if grep ^FEATURES ../Makefile | cut -d'#' -f1 | grep -q BIP68; then
SEQ_ENFORCEMENT=true SEQ_ENFORCEMENT=true
else else
SEQ_ENFORCEMENT=false SEQ_ENFORCEMENT=false
fi
fi fi
#PREFIX="valgrind --vgdb-error=1" #PREFIX="valgrind --vgdb-error=1"

Write Preview
Loading…
Cancel
Save