You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1565 lines
40 KiB
1565 lines
40 KiB
/* This file was generated by generate-wire.py */
|
|
/* Do not modify this file! Modify the .csv file it was generated from. */
|
|
/* Original template can be found at tools/gen/impl_template */
|
|
|
|
#include <wire/bolt12_wiregen.h>
|
|
#include <assert.h>
|
|
#include <ccan/array_size/array_size.h>
|
|
#include <ccan/mem/mem.h>
|
|
#include <ccan/tal/str/str.h>
|
|
#include <common/utils.h>
|
|
#include <stdio.h>
|
|
|
|
#ifndef SUPERVERBOSE
|
|
#define SUPERVERBOSE(...)
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* SUBTYPE: BLINDED_PATH */
|
|
void towire_blinded_path(u8 **p, const struct blinded_path *blinded_path)
|
|
{
|
|
u16 num_hops = tal_count(blinded_path->path);
|
|
|
|
towire_pubkey(p, &blinded_path->blinding);
|
|
towire_u16(p, num_hops);
|
|
for (size_t i = 0; i < num_hops; i++)
|
|
towire_onionmsg_path(p, blinded_path->path[i]);
|
|
}
|
|
struct blinded_path *
|
|
fromwire_blinded_path(const tal_t *ctx, const u8 **cursor, size_t *plen)
|
|
{
|
|
struct blinded_path *blinded_path = tal(ctx, struct blinded_path);
|
|
u16 num_hops;
|
|
|
|
fromwire_pubkey(cursor, plen, &blinded_path->blinding);
|
|
num_hops = fromwire_u16(cursor, plen);
|
|
blinded_path->path = num_hops ? tal_arr(blinded_path, struct onionmsg_path *, 0) : NULL;
|
|
for (size_t i = 0; i < num_hops; i++) {
|
|
struct onionmsg_path * tmp;
|
|
tmp = fromwire_onionmsg_path(blinded_path, cursor, plen);
|
|
tal_arr_expand(&blinded_path->path, tmp);
|
|
}
|
|
|
|
return blinded_path;
|
|
}
|
|
|
|
/* SUBTYPE: BLINDED_PAYINFO */
|
|
void towire_blinded_payinfo(u8 **p, const struct blinded_payinfo *blinded_payinfo)
|
|
{
|
|
u16 flen = tal_count(blinded_payinfo->features);
|
|
|
|
towire_u32(p, blinded_payinfo->fee_base_msat);
|
|
towire_u32(p, blinded_payinfo->fee_proportional_millionths);
|
|
towire_u16(p, blinded_payinfo->cltv_expiry_delta);
|
|
towire_u16(p, flen);
|
|
towire_u8_array(p, blinded_payinfo->features, flen);
|
|
}
|
|
struct blinded_payinfo *
|
|
fromwire_blinded_payinfo(const tal_t *ctx, const u8 **cursor, size_t *plen)
|
|
{
|
|
struct blinded_payinfo *blinded_payinfo = tal(ctx, struct blinded_payinfo);
|
|
u16 flen;
|
|
|
|
blinded_payinfo->fee_base_msat = fromwire_u32(cursor, plen);
|
|
blinded_payinfo->fee_proportional_millionths = fromwire_u32(cursor, plen);
|
|
blinded_payinfo->cltv_expiry_delta = fromwire_u16(cursor, plen);
|
|
flen = fromwire_u16(cursor, plen);
|
|
blinded_payinfo->features = flen ? tal_arr(blinded_payinfo, u8, flen) : NULL;
|
|
fromwire_u8_array(cursor, plen, blinded_payinfo->features, flen);
|
|
|
|
return blinded_payinfo;
|
|
}
|
|
|
|
/* SUBTYPE: FALLBACK_ADDRESS */
|
|
void towire_fallback_address(u8 **p, const struct fallback_address *fallback_address)
|
|
{
|
|
u16 len = tal_count(fallback_address->address);
|
|
|
|
towire_u8(p, fallback_address->version);
|
|
towire_u16(p, len);
|
|
towire_u8_array(p, fallback_address->address, len);
|
|
}
|
|
struct fallback_address *
|
|
fromwire_fallback_address(const tal_t *ctx, const u8 **cursor, size_t *plen)
|
|
{
|
|
struct fallback_address *fallback_address = tal(ctx, struct fallback_address);
|
|
u16 len;
|
|
|
|
fallback_address->version = fromwire_u8(cursor, plen);
|
|
len = fromwire_u16(cursor, plen);
|
|
fallback_address->address = len ? tal_arr(fallback_address, u8, len) : NULL;
|
|
fromwire_u8_array(cursor, plen, fallback_address->address, len);
|
|
|
|
return fallback_address;
|
|
}
|
|
|
|
|
|
struct tlv_offer *tlv_offer_new(const tal_t *ctx)
|
|
{
|
|
/* Initialize everything to NULL. (Quiet, C pedants!) */
|
|
struct tlv_offer *inst = talz(ctx, struct tlv_offer);
|
|
|
|
/* Initialized the fields to an empty array. */
|
|
inst->fields = tal_arr(inst, struct tlv_field, 0);
|
|
return inst;
|
|
}
|
|
|
|
/* OFFER MSG: chains */
|
|
static u8 *towire_tlv_offer_chains(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->chains)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->chains); i++)
|
|
towire_bitcoin_blkid(&ptr, r->chains + i);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_chains(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->chains = *plen ? tal_arr(r, struct bitcoin_blkid, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct bitcoin_blkid tmp;
|
|
fromwire_bitcoin_blkid(cursor, plen, &tmp);
|
|
tal_arr_expand(&r->chains, tmp);
|
|
}
|
|
}
|
|
/* OFFER MSG: currency */
|
|
static u8 *towire_tlv_offer_currency(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->currency)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->currency, tal_count(r->currency));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_currency(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->currency = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->currency, *plen);
|
|
}
|
|
/* OFFER MSG: amount */
|
|
static u8 *towire_tlv_offer_amount(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->amount)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->amount);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_amount(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->amount = tal(r, u64);
|
|
|
|
*r->amount = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* OFFER MSG: description */
|
|
static u8 *towire_tlv_offer_description(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->description)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->description, tal_count(r->description));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_description(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->description = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->description, *plen);
|
|
}
|
|
/* OFFER MSG: features */
|
|
static u8 *towire_tlv_offer_features(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->features)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->features, tal_count(r->features));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_features(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->features = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->features, *plen);
|
|
}
|
|
/* OFFER MSG: absolute_expiry */
|
|
static u8 *towire_tlv_offer_absolute_expiry(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->absolute_expiry)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->absolute_expiry);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_absolute_expiry(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->absolute_expiry = tal(r, u64);
|
|
|
|
*r->absolute_expiry = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* OFFER MSG: paths */
|
|
static u8 *towire_tlv_offer_paths(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->paths)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->paths); i++)
|
|
towire_blinded_path(&ptr, r->paths[i]);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_paths(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->paths = *plen ? tal_arr(r, struct blinded_path *, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct blinded_path * tmp;
|
|
tmp = fromwire_blinded_path(r, cursor, plen);
|
|
tal_arr_expand(&r->paths, tmp);
|
|
}
|
|
}
|
|
/* OFFER MSG: vendor */
|
|
static u8 *towire_tlv_offer_vendor(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->vendor)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->vendor, tal_count(r->vendor));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_vendor(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->vendor = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->vendor, *plen);
|
|
}
|
|
/* OFFER MSG: quantity_min */
|
|
static u8 *towire_tlv_offer_quantity_min(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->quantity_min)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->quantity_min);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_quantity_min(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->quantity_min = tal(r, u64);
|
|
|
|
*r->quantity_min = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* OFFER MSG: quantity_max */
|
|
static u8 *towire_tlv_offer_quantity_max(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->quantity_max)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->quantity_max);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_quantity_max(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->quantity_max = tal(r, u64);
|
|
|
|
*r->quantity_max = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* OFFER MSG: recurrence */
|
|
static u8 *towire_tlv_offer_recurrence(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8(&ptr, r->recurrence->time_unit);
|
|
|
|
towire_tu32(&ptr, r->recurrence->period);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_recurrence(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->recurrence = tal(r, struct tlv_offer_recurrence);
|
|
r->recurrence->time_unit = fromwire_u8(cursor, plen);
|
|
r->recurrence->period = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* OFFER MSG: recurrence_paywindow */
|
|
static u8 *towire_tlv_offer_recurrence_paywindow(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_paywindow)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u32(&ptr, r->recurrence_paywindow->seconds_before);
|
|
|
|
towire_u8(&ptr, r->recurrence_paywindow->proportional_amount);
|
|
|
|
towire_tu32(&ptr, r->recurrence_paywindow->seconds_after);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_recurrence_paywindow(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->recurrence_paywindow = tal(r, struct tlv_offer_recurrence_paywindow);
|
|
r->recurrence_paywindow->seconds_before = fromwire_u32(cursor, plen);
|
|
r->recurrence_paywindow->proportional_amount = fromwire_u8(cursor, plen);
|
|
r->recurrence_paywindow->seconds_after = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* OFFER MSG: recurrence_limit */
|
|
static u8 *towire_tlv_offer_recurrence_limit(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_limit)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->recurrence_limit);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_recurrence_limit(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->recurrence_limit = tal(r, u32);
|
|
|
|
*r->recurrence_limit = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* OFFER MSG: recurrence_base */
|
|
static u8 *towire_tlv_offer_recurrence_base(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_base)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8(&ptr, r->recurrence_base->start_any_period);
|
|
|
|
towire_tu64(&ptr, r->recurrence_base->basetime);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_recurrence_base(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->recurrence_base = tal(r, struct tlv_offer_recurrence_base);
|
|
r->recurrence_base->start_any_period = fromwire_u8(cursor, plen);
|
|
r->recurrence_base->basetime = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* OFFER MSG: node_id */
|
|
static u8 *towire_tlv_offer_node_id(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->node_id)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_pubkey32(&ptr, r->node_id);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_node_id(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->node_id = tal(r, struct pubkey32);
|
|
|
|
fromwire_pubkey32(cursor, plen, &*r->node_id);
|
|
}
|
|
/* OFFER MSG: send_invoice */
|
|
static u8 *towire_tlv_offer_send_invoice(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->send_invoice)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_send_invoice(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->send_invoice = tal(r, struct tlv_offer_send_invoice);
|
|
}
|
|
/* OFFER MSG: refund_for */
|
|
static u8 *towire_tlv_offer_refund_for(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->refund_for)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_sha256(&ptr, r->refund_for);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_refund_for(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->refund_for = tal(r, struct sha256);
|
|
|
|
fromwire_sha256(cursor, plen, &*r->refund_for);
|
|
}
|
|
/* OFFER MSG: signature */
|
|
static u8 *towire_tlv_offer_signature(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_offer *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->signature)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_bip340sig(&ptr, r->signature);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_offer_signature(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_offer *r = vrecord;
|
|
|
|
r->signature = tal(r, struct bip340sig);
|
|
|
|
fromwire_bip340sig(cursor, plen, &*r->signature);
|
|
}
|
|
|
|
static const struct tlv_record_type tlvs_offer[] = {
|
|
{ 2, towire_tlv_offer_chains, fromwire_tlv_offer_chains },
|
|
{ 6, towire_tlv_offer_currency, fromwire_tlv_offer_currency },
|
|
{ 8, towire_tlv_offer_amount, fromwire_tlv_offer_amount },
|
|
{ 10, towire_tlv_offer_description, fromwire_tlv_offer_description },
|
|
{ 12, towire_tlv_offer_features, fromwire_tlv_offer_features },
|
|
{ 14, towire_tlv_offer_absolute_expiry, fromwire_tlv_offer_absolute_expiry },
|
|
{ 16, towire_tlv_offer_paths, fromwire_tlv_offer_paths },
|
|
{ 20, towire_tlv_offer_vendor, fromwire_tlv_offer_vendor },
|
|
{ 22, towire_tlv_offer_quantity_min, fromwire_tlv_offer_quantity_min },
|
|
{ 24, towire_tlv_offer_quantity_max, fromwire_tlv_offer_quantity_max },
|
|
{ 26, towire_tlv_offer_recurrence, fromwire_tlv_offer_recurrence },
|
|
{ 28, towire_tlv_offer_recurrence_base, fromwire_tlv_offer_recurrence_base },
|
|
{ 30, towire_tlv_offer_node_id, fromwire_tlv_offer_node_id },
|
|
{ 34, towire_tlv_offer_refund_for, fromwire_tlv_offer_refund_for },
|
|
{ 54, towire_tlv_offer_send_invoice, fromwire_tlv_offer_send_invoice },
|
|
{ 64, towire_tlv_offer_recurrence_paywindow, fromwire_tlv_offer_recurrence_paywindow },
|
|
{ 66, towire_tlv_offer_recurrence_limit, fromwire_tlv_offer_recurrence_limit },
|
|
{ 240, towire_tlv_offer_signature, fromwire_tlv_offer_signature },
|
|
};
|
|
|
|
void towire_offer(u8 **pptr, const struct tlv_offer *record)
|
|
{
|
|
towire_tlv(pptr, tlvs_offer, 18, record);
|
|
}
|
|
|
|
|
|
bool fromwire_offer(const u8 **cursor, size_t *max, struct tlv_offer *record)
|
|
{
|
|
return fromwire_tlv(cursor, max, tlvs_offer, 18, record, &record->fields);
|
|
}
|
|
|
|
bool offer_is_valid(const struct tlv_offer *record, size_t *err_index)
|
|
{
|
|
return tlv_fields_valid(record->fields, err_index);
|
|
}
|
|
|
|
|
|
struct tlv_invoice_request *tlv_invoice_request_new(const tal_t *ctx)
|
|
{
|
|
/* Initialize everything to NULL. (Quiet, C pedants!) */
|
|
struct tlv_invoice_request *inst = talz(ctx, struct tlv_invoice_request);
|
|
|
|
/* Initialized the fields to an empty array. */
|
|
inst->fields = tal_arr(inst, struct tlv_field, 0);
|
|
return inst;
|
|
}
|
|
|
|
/* INVOICE_REQUEST MSG: chains */
|
|
static u8 *towire_tlv_invoice_request_chains(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->chains)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->chains); i++)
|
|
towire_bitcoin_blkid(&ptr, r->chains + i);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_chains(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->chains = *plen ? tal_arr(r, struct bitcoin_blkid, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct bitcoin_blkid tmp;
|
|
fromwire_bitcoin_blkid(cursor, plen, &tmp);
|
|
tal_arr_expand(&r->chains, tmp);
|
|
}
|
|
}
|
|
/* INVOICE_REQUEST MSG: offer_id */
|
|
static u8 *towire_tlv_invoice_request_offer_id(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->offer_id)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_sha256(&ptr, r->offer_id);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_offer_id(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->offer_id = tal(r, struct sha256);
|
|
|
|
fromwire_sha256(cursor, plen, &*r->offer_id);
|
|
}
|
|
/* INVOICE_REQUEST MSG: amount */
|
|
static u8 *towire_tlv_invoice_request_amount(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->amount)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->amount);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_amount(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->amount = tal(r, u64);
|
|
|
|
*r->amount = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: features */
|
|
static u8 *towire_tlv_invoice_request_features(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->features)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->features, tal_count(r->features));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_features(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->features = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->features, *plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: quantity */
|
|
static u8 *towire_tlv_invoice_request_quantity(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->quantity)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->quantity);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_quantity(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->quantity = tal(r, u64);
|
|
|
|
*r->quantity = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: recurrence_counter */
|
|
static u8 *towire_tlv_invoice_request_recurrence_counter(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_counter)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->recurrence_counter);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_recurrence_counter(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->recurrence_counter = tal(r, u32);
|
|
|
|
*r->recurrence_counter = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: recurrence_start */
|
|
static u8 *towire_tlv_invoice_request_recurrence_start(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_start)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->recurrence_start);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_recurrence_start(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->recurrence_start = tal(r, u32);
|
|
|
|
*r->recurrence_start = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: payer_key */
|
|
static u8 *towire_tlv_invoice_request_payer_key(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->payer_key)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_pubkey32(&ptr, r->payer_key);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_payer_key(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->payer_key = tal(r, struct pubkey32);
|
|
|
|
fromwire_pubkey32(cursor, plen, &*r->payer_key);
|
|
}
|
|
/* INVOICE_REQUEST MSG: payer_info */
|
|
static u8 *towire_tlv_invoice_request_payer_info(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->payer_info)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->payer_info, tal_count(r->payer_info));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_payer_info(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->payer_info = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->payer_info, *plen);
|
|
}
|
|
/* INVOICE_REQUEST MSG: recurrence_signature */
|
|
static u8 *towire_tlv_invoice_request_recurrence_signature(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_request *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_signature)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_bip340sig(&ptr, r->recurrence_signature);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_request_recurrence_signature(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_request *r = vrecord;
|
|
|
|
r->recurrence_signature = tal(r, struct bip340sig);
|
|
|
|
fromwire_bip340sig(cursor, plen, &*r->recurrence_signature);
|
|
}
|
|
|
|
const struct tlv_record_type tlvs_invoice_request[] = {
|
|
{ 2, towire_tlv_invoice_request_chains, fromwire_tlv_invoice_request_chains },
|
|
{ 4, towire_tlv_invoice_request_offer_id, fromwire_tlv_invoice_request_offer_id },
|
|
{ 8, towire_tlv_invoice_request_amount, fromwire_tlv_invoice_request_amount },
|
|
{ 12, towire_tlv_invoice_request_features, fromwire_tlv_invoice_request_features },
|
|
{ 32, towire_tlv_invoice_request_quantity, fromwire_tlv_invoice_request_quantity },
|
|
{ 36, towire_tlv_invoice_request_recurrence_counter, fromwire_tlv_invoice_request_recurrence_counter },
|
|
{ 38, towire_tlv_invoice_request_payer_key, fromwire_tlv_invoice_request_payer_key },
|
|
{ 50, towire_tlv_invoice_request_payer_info, fromwire_tlv_invoice_request_payer_info },
|
|
{ 68, towire_tlv_invoice_request_recurrence_start, fromwire_tlv_invoice_request_recurrence_start },
|
|
{ 242, towire_tlv_invoice_request_recurrence_signature, fromwire_tlv_invoice_request_recurrence_signature },
|
|
};
|
|
|
|
void towire_invoice_request(u8 **pptr, const struct tlv_invoice_request *record)
|
|
{
|
|
towire_tlv(pptr, tlvs_invoice_request, 10, record);
|
|
}
|
|
|
|
|
|
bool fromwire_invoice_request(const u8 **cursor, size_t *max, struct tlv_invoice_request *record)
|
|
{
|
|
return fromwire_tlv(cursor, max, tlvs_invoice_request, 10, record, &record->fields);
|
|
}
|
|
|
|
bool invoice_request_is_valid(const struct tlv_invoice_request *record, size_t *err_index)
|
|
{
|
|
return tlv_fields_valid(record->fields, err_index);
|
|
}
|
|
|
|
|
|
struct tlv_invoice *tlv_invoice_new(const tal_t *ctx)
|
|
{
|
|
/* Initialize everything to NULL. (Quiet, C pedants!) */
|
|
struct tlv_invoice *inst = talz(ctx, struct tlv_invoice);
|
|
|
|
/* Initialized the fields to an empty array. */
|
|
inst->fields = tal_arr(inst, struct tlv_field, 0);
|
|
return inst;
|
|
}
|
|
|
|
/* INVOICE MSG: chains */
|
|
static u8 *towire_tlv_invoice_chains(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->chains)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->chains); i++)
|
|
towire_bitcoin_blkid(&ptr, r->chains + i);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_chains(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->chains = *plen ? tal_arr(r, struct bitcoin_blkid, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct bitcoin_blkid tmp;
|
|
fromwire_bitcoin_blkid(cursor, plen, &tmp);
|
|
tal_arr_expand(&r->chains, tmp);
|
|
}
|
|
}
|
|
/* INVOICE MSG: offer_id */
|
|
static u8 *towire_tlv_invoice_offer_id(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->offer_id)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_sha256(&ptr, r->offer_id);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_offer_id(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->offer_id = tal(r, struct sha256);
|
|
|
|
fromwire_sha256(cursor, plen, &*r->offer_id);
|
|
}
|
|
/* INVOICE MSG: amount */
|
|
static u8 *towire_tlv_invoice_amount(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->amount)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->amount);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_amount(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->amount = tal(r, u64);
|
|
|
|
*r->amount = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: description */
|
|
static u8 *towire_tlv_invoice_description(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->description)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->description, tal_count(r->description));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_description(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->description = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->description, *plen);
|
|
}
|
|
/* INVOICE MSG: features */
|
|
static u8 *towire_tlv_invoice_features(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->features)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->features, tal_count(r->features));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_features(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->features = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->features, *plen);
|
|
}
|
|
/* INVOICE MSG: paths */
|
|
static u8 *towire_tlv_invoice_paths(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->paths)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->paths); i++)
|
|
towire_blinded_path(&ptr, r->paths[i]);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_paths(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->paths = *plen ? tal_arr(r, struct blinded_path *, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct blinded_path * tmp;
|
|
tmp = fromwire_blinded_path(r, cursor, plen);
|
|
tal_arr_expand(&r->paths, tmp);
|
|
}
|
|
}
|
|
/* INVOICE MSG: blindedpay */
|
|
static u8 *towire_tlv_invoice_blindedpay(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->blindedpay)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
for (size_t i = 0; i < tal_count(r->blindedpay); i++)
|
|
towire_blinded_payinfo(&ptr, r->blindedpay[i]);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_blindedpay(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->blindedpay = *plen ? tal_arr(r, struct blinded_payinfo *, 0) : NULL;
|
|
for (size_t i = 0; *plen != 0; i++) {
|
|
struct blinded_payinfo * tmp;
|
|
tmp = fromwire_blinded_payinfo(r, cursor, plen);
|
|
tal_arr_expand(&r->blindedpay, tmp);
|
|
}
|
|
}
|
|
/* INVOICE MSG: vendor */
|
|
static u8 *towire_tlv_invoice_vendor(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->vendor)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->vendor, tal_count(r->vendor));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_vendor(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->vendor = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->vendor, *plen);
|
|
}
|
|
/* INVOICE MSG: node_id */
|
|
static u8 *towire_tlv_invoice_node_id(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->node_id)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_pubkey32(&ptr, r->node_id);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_node_id(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->node_id = tal(r, struct pubkey32);
|
|
|
|
fromwire_pubkey32(cursor, plen, &*r->node_id);
|
|
}
|
|
/* INVOICE MSG: quantity */
|
|
static u8 *towire_tlv_invoice_quantity(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->quantity)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->quantity);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_quantity(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->quantity = tal(r, u64);
|
|
|
|
*r->quantity = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: refund_for */
|
|
static u8 *towire_tlv_invoice_refund_for(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->refund_for)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_sha256(&ptr, r->refund_for);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_refund_for(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->refund_for = tal(r, struct sha256);
|
|
|
|
fromwire_sha256(cursor, plen, &*r->refund_for);
|
|
}
|
|
/* INVOICE MSG: recurrence_counter */
|
|
static u8 *towire_tlv_invoice_recurrence_counter(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_counter)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->recurrence_counter);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_recurrence_counter(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->recurrence_counter = tal(r, u32);
|
|
|
|
*r->recurrence_counter = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: send_invoice */
|
|
static u8 *towire_tlv_invoice_send_invoice(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->send_invoice)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_send_invoice(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->send_invoice = tal(r, struct tlv_invoice_send_invoice);
|
|
}
|
|
/* INVOICE MSG: recurrence_start */
|
|
static u8 *towire_tlv_invoice_recurrence_start(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_start)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->recurrence_start);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_recurrence_start(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->recurrence_start = tal(r, u32);
|
|
|
|
*r->recurrence_start = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: recurrence_basetime */
|
|
static u8 *towire_tlv_invoice_recurrence_basetime(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->recurrence_basetime)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->recurrence_basetime);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_recurrence_basetime(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->recurrence_basetime = tal(r, u64);
|
|
|
|
*r->recurrence_basetime = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: payer_key */
|
|
static u8 *towire_tlv_invoice_payer_key(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->payer_key)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_pubkey32(&ptr, r->payer_key);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_payer_key(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->payer_key = tal(r, struct pubkey32);
|
|
|
|
fromwire_pubkey32(cursor, plen, &*r->payer_key);
|
|
}
|
|
/* INVOICE MSG: payer_info */
|
|
static u8 *towire_tlv_invoice_payer_info(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->payer_info)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->payer_info, tal_count(r->payer_info));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_payer_info(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->payer_info = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->payer_info, *plen);
|
|
}
|
|
/* INVOICE MSG: timestamp */
|
|
static u8 *towire_tlv_invoice_timestamp(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->timestamp)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->timestamp);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_timestamp(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->timestamp = tal(r, u64);
|
|
|
|
*r->timestamp = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: payment_hash */
|
|
static u8 *towire_tlv_invoice_payment_hash(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->payment_hash)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_sha256(&ptr, r->payment_hash);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_payment_hash(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->payment_hash = tal(r, struct sha256);
|
|
|
|
fromwire_sha256(cursor, plen, &*r->payment_hash);
|
|
}
|
|
/* INVOICE MSG: relative_expiry */
|
|
static u8 *towire_tlv_invoice_relative_expiry(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->relative_expiry)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->relative_expiry);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_relative_expiry(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->relative_expiry = tal(r, u32);
|
|
|
|
*r->relative_expiry = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: cltv */
|
|
static u8 *towire_tlv_invoice_cltv(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->cltv)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu32(&ptr, *r->cltv);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_cltv(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->cltv = tal(r, u32);
|
|
|
|
*r->cltv = fromwire_tu32(cursor, plen);
|
|
}
|
|
/* INVOICE MSG: fallbacks */
|
|
static u8 *towire_tlv_invoice_fallbacks(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->fallbacks)
|
|
return NULL;
|
|
|
|
u8 num = tal_count(r->fallbacks->fallbacks);
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8(&ptr, num);
|
|
|
|
for (size_t i = 0; i < num; i++)
|
|
towire_fallback_address(&ptr, r->fallbacks->fallbacks[i]);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_fallbacks(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
u8 num;
|
|
|
|
r->fallbacks = tal(r, struct tlv_invoice_fallbacks);
|
|
num = fromwire_u8(cursor, plen);
|
|
r->fallbacks->fallbacks = num ? tal_arr(r->fallbacks, struct fallback_address *, 0) : NULL;
|
|
for (size_t i = 0; i < num; i++) {
|
|
struct fallback_address * tmp;
|
|
tmp = fromwire_fallback_address(r->fallbacks, cursor, plen);
|
|
tal_arr_expand(&r->fallbacks->fallbacks, tmp);
|
|
}
|
|
}
|
|
/* INVOICE MSG: refund_signature */
|
|
static u8 *towire_tlv_invoice_refund_signature(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->refund_signature)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_bip340sig(&ptr, r->refund_signature);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_refund_signature(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->refund_signature = tal(r, struct bip340sig);
|
|
|
|
fromwire_bip340sig(cursor, plen, &*r->refund_signature);
|
|
}
|
|
/* INVOICE MSG: signature */
|
|
static u8 *towire_tlv_invoice_signature(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->signature)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_bip340sig(&ptr, r->signature);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_signature(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice *r = vrecord;
|
|
|
|
r->signature = tal(r, struct bip340sig);
|
|
|
|
fromwire_bip340sig(cursor, plen, &*r->signature);
|
|
}
|
|
|
|
static const struct tlv_record_type tlvs_invoice[] = {
|
|
{ 2, towire_tlv_invoice_chains, fromwire_tlv_invoice_chains },
|
|
{ 4, towire_tlv_invoice_offer_id, fromwire_tlv_invoice_offer_id },
|
|
{ 8, towire_tlv_invoice_amount, fromwire_tlv_invoice_amount },
|
|
{ 10, towire_tlv_invoice_description, fromwire_tlv_invoice_description },
|
|
{ 12, towire_tlv_invoice_features, fromwire_tlv_invoice_features },
|
|
{ 16, towire_tlv_invoice_paths, fromwire_tlv_invoice_paths },
|
|
{ 18, towire_tlv_invoice_blindedpay, fromwire_tlv_invoice_blindedpay },
|
|
{ 20, towire_tlv_invoice_vendor, fromwire_tlv_invoice_vendor },
|
|
{ 30, towire_tlv_invoice_node_id, fromwire_tlv_invoice_node_id },
|
|
{ 32, towire_tlv_invoice_quantity, fromwire_tlv_invoice_quantity },
|
|
{ 34, towire_tlv_invoice_refund_for, fromwire_tlv_invoice_refund_for },
|
|
{ 36, towire_tlv_invoice_recurrence_counter, fromwire_tlv_invoice_recurrence_counter },
|
|
{ 38, towire_tlv_invoice_payer_key, fromwire_tlv_invoice_payer_key },
|
|
{ 40, towire_tlv_invoice_timestamp, fromwire_tlv_invoice_timestamp },
|
|
{ 42, towire_tlv_invoice_payment_hash, fromwire_tlv_invoice_payment_hash },
|
|
{ 44, towire_tlv_invoice_relative_expiry, fromwire_tlv_invoice_relative_expiry },
|
|
{ 46, towire_tlv_invoice_cltv, fromwire_tlv_invoice_cltv },
|
|
{ 48, towire_tlv_invoice_fallbacks, fromwire_tlv_invoice_fallbacks },
|
|
{ 50, towire_tlv_invoice_payer_info, fromwire_tlv_invoice_payer_info },
|
|
{ 52, towire_tlv_invoice_refund_signature, fromwire_tlv_invoice_refund_signature },
|
|
{ 54, towire_tlv_invoice_send_invoice, fromwire_tlv_invoice_send_invoice },
|
|
{ 64, towire_tlv_invoice_recurrence_basetime, fromwire_tlv_invoice_recurrence_basetime },
|
|
{ 68, towire_tlv_invoice_recurrence_start, fromwire_tlv_invoice_recurrence_start },
|
|
{ 240, towire_tlv_invoice_signature, fromwire_tlv_invoice_signature },
|
|
};
|
|
|
|
void towire_invoice(u8 **pptr, const struct tlv_invoice *record)
|
|
{
|
|
towire_tlv(pptr, tlvs_invoice, 24, record);
|
|
}
|
|
|
|
|
|
bool fromwire_invoice(const u8 **cursor, size_t *max, struct tlv_invoice *record)
|
|
{
|
|
return fromwire_tlv(cursor, max, tlvs_invoice, 24, record, &record->fields);
|
|
}
|
|
|
|
bool invoice_is_valid(const struct tlv_invoice *record, size_t *err_index)
|
|
{
|
|
return tlv_fields_valid(record->fields, err_index);
|
|
}
|
|
|
|
|
|
struct tlv_invoice_error *tlv_invoice_error_new(const tal_t *ctx)
|
|
{
|
|
/* Initialize everything to NULL. (Quiet, C pedants!) */
|
|
struct tlv_invoice_error *inst = talz(ctx, struct tlv_invoice_error);
|
|
|
|
/* Initialized the fields to an empty array. */
|
|
inst->fields = tal_arr(inst, struct tlv_field, 0);
|
|
return inst;
|
|
}
|
|
|
|
/* INVOICE_ERROR MSG: erroneous_field */
|
|
static u8 *towire_tlv_invoice_error_erroneous_field(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_error *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->erroneous_field)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_tu64(&ptr, *r->erroneous_field);
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_error_erroneous_field(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_error *r = vrecord;
|
|
|
|
r->erroneous_field = tal(r, u64);
|
|
|
|
*r->erroneous_field = fromwire_tu64(cursor, plen);
|
|
}
|
|
/* INVOICE_ERROR MSG: suggested_value */
|
|
static u8 *towire_tlv_invoice_error_suggested_value(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_error *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->suggested_value)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u8_array(&ptr, r->suggested_value, tal_count(r->suggested_value));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_error_suggested_value(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_error *r = vrecord;
|
|
|
|
r->suggested_value = *plen ? tal_arr(r, u8, *plen) : NULL;
|
|
fromwire_u8_array(cursor, plen, r->suggested_value, *plen);
|
|
}
|
|
/* INVOICE_ERROR MSG: error */
|
|
static u8 *towire_tlv_invoice_error_error(const tal_t *ctx, const void *vrecord)
|
|
{
|
|
const struct tlv_invoice_error *r = vrecord;
|
|
u8 *ptr;
|
|
|
|
if (!r->error)
|
|
return NULL;
|
|
|
|
|
|
ptr = tal_arr(ctx, u8, 0);
|
|
|
|
towire_utf8_array(&ptr, r->error, tal_count(r->error));
|
|
return ptr;
|
|
}
|
|
static void fromwire_tlv_invoice_error_error(const u8 **cursor, size_t *plen, void *vrecord)
|
|
{
|
|
struct tlv_invoice_error *r = vrecord;
|
|
|
|
r->error = *plen ? tal_arr(r, utf8, *plen) : NULL;
|
|
fromwire_utf8_array(cursor, plen, r->error, *plen);
|
|
}
|
|
|
|
static const struct tlv_record_type tlvs_invoice_error[] = {
|
|
{ 1, towire_tlv_invoice_error_erroneous_field, fromwire_tlv_invoice_error_erroneous_field },
|
|
{ 3, towire_tlv_invoice_error_suggested_value, fromwire_tlv_invoice_error_suggested_value },
|
|
{ 5, towire_tlv_invoice_error_error, fromwire_tlv_invoice_error_error },
|
|
};
|
|
|
|
void towire_invoice_error(u8 **pptr, const struct tlv_invoice_error *record)
|
|
{
|
|
towire_tlv(pptr, tlvs_invoice_error, 3, record);
|
|
}
|
|
|
|
|
|
bool fromwire_invoice_error(const u8 **cursor, size_t *max, struct tlv_invoice_error *record)
|
|
{
|
|
return fromwire_tlv(cursor, max, tlvs_invoice_error, 3, record, &record->fields);
|
|
}
|
|
|
|
bool invoice_error_is_valid(const struct tlv_invoice_error *record, size_t *err_index)
|
|
{
|
|
return tlv_fields_valid(record->fields, err_index);
|
|
}
|
|
|
|
// SHA256STAMP:b09ebf868d0b5b9792d0054bee17d763c1243d18c419847c554c63aefb7a8548
|
|
|