mirror of
https://github.com/ElementsProject/lightning.git
synced 2024-11-19 09:54:16 +01:00
9a0163ec85
Our current proto_to_locktime actually handles relative locktimes, and HTLCs use absolute. Fix that. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
114 lines
2.6 KiB
C
114 lines
2.6 KiB
C
#include <ccan/crypto/sha256/sha256.h>
|
|
#include "bitcoin/pubkey.h"
|
|
#include "bitcoin/signature.h"
|
|
#include "protobuf_convert.h"
|
|
|
|
Signature *signature_to_proto(const tal_t *ctx, const struct signature *sig)
|
|
{
|
|
Signature *pb = tal(ctx, Signature);
|
|
signature__init(pb);
|
|
|
|
assert(sig_valid(sig));
|
|
|
|
/* Kill me now... */
|
|
memcpy(&pb->r1, sig->r, 8);
|
|
memcpy(&pb->r2, sig->r + 8, 8);
|
|
memcpy(&pb->r3, sig->r + 16, 8);
|
|
memcpy(&pb->r4, sig->r + 24, 8);
|
|
memcpy(&pb->s1, sig->s, 8);
|
|
memcpy(&pb->s2, sig->s + 8, 8);
|
|
memcpy(&pb->s3, sig->s + 16, 8);
|
|
memcpy(&pb->s4, sig->s + 24, 8);
|
|
|
|
return pb;
|
|
}
|
|
|
|
bool proto_to_signature(const Signature *pb, struct signature *sig)
|
|
{
|
|
/* Kill me again. */
|
|
memcpy(sig->r, &pb->r1, 8);
|
|
memcpy(sig->r + 8, &pb->r2, 8);
|
|
memcpy(sig->r + 16, &pb->r3, 8);
|
|
memcpy(sig->r + 24, &pb->r4, 8);
|
|
memcpy(sig->s, &pb->s1, 8);
|
|
memcpy(sig->s + 8, &pb->s2, 8);
|
|
memcpy(sig->s + 16, &pb->s3, 8);
|
|
memcpy(sig->s + 24, &pb->s4, 8);
|
|
|
|
return sig_valid(sig);
|
|
}
|
|
|
|
BitcoinPubkey *pubkey_to_proto(const tal_t *ctx, const struct pubkey *key)
|
|
{
|
|
BitcoinPubkey *p = tal(ctx, BitcoinPubkey);
|
|
|
|
bitcoin_pubkey__init(p);
|
|
p->key.len = pubkey_len(key);
|
|
p->key.data = tal_dup_arr(p, u8, key->key, p->key.len, 0);
|
|
|
|
assert(pubkey_valid(p->key.data, p->key.len));
|
|
return p;
|
|
}
|
|
|
|
bool proto_to_pubkey(const BitcoinPubkey *pb, struct pubkey *key)
|
|
{
|
|
if (!pubkey_valid(pb->key.data, pb->key.len))
|
|
return false;
|
|
|
|
memcpy(key->key, pb->key.data, pb->key.len);
|
|
return true;
|
|
}
|
|
|
|
Sha256Hash *sha256_to_proto(const tal_t *ctx, const struct sha256 *hash)
|
|
{
|
|
Sha256Hash *h = tal(ctx, Sha256Hash);
|
|
sha256_hash__init(h);
|
|
|
|
/* Kill me now... */
|
|
memcpy(&h->a, hash->u.u8, 8);
|
|
memcpy(&h->b, hash->u.u8 + 8, 8);
|
|
memcpy(&h->c, hash->u.u8 + 16, 8);
|
|
memcpy(&h->d, hash->u.u8 + 24, 8);
|
|
return h;
|
|
}
|
|
|
|
void proto_to_sha256(const Sha256Hash *pb, struct sha256 *hash)
|
|
{
|
|
/* Kill me again. */
|
|
memcpy(hash->u.u8, &pb->a, 8);
|
|
memcpy(hash->u.u8 + 8, &pb->b, 8);
|
|
memcpy(hash->u.u8 + 16, &pb->c, 8);
|
|
memcpy(hash->u.u8 + 24, &pb->d, 8);
|
|
}
|
|
|
|
static bool proto_to_locktime(const Locktime *l, uint32_t off,
|
|
uint32_t *locktime)
|
|
{
|
|
switch (l->locktime_case) {
|
|
case LOCKTIME__LOCKTIME_SECONDS:
|
|
*locktime = off + l->seconds;
|
|
/* Check for wrap, or too low value */
|
|
if (*locktime < 500000000)
|
|
return false;
|
|
break;
|
|
case LOCKTIME__LOCKTIME_BLOCKS:
|
|
if (l->blocks >= 500000000)
|
|
return false;
|
|
*locktime = l->blocks;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool proto_to_rel_locktime(const Locktime *l, uint32_t *locktime)
|
|
{
|
|
return proto_to_locktime(l, 500000000, locktime);
|
|
}
|
|
|
|
bool proto_to_abs_locktime(const Locktime *l, uint32_t *locktime)
|
|
{
|
|
return proto_to_locktime(l, 0, locktime);
|
|
}
|