bolt12-test/gencode.js

Decode bolt12 type address for the lightning networks.

var assert = require('assert');
const {
    towire_byte,
    fromwire_byte,
    towire_chain_hash,
    fromwire_chain_hash,
    towire_channel_id,
    fromwire_channel_id,
    towire_array_utf8,
    fromwire_array_utf8,
    towire_bigsize,
    fromwire_bigsize,
    towire_point,
    fromwire_point,
    towire_point32,
    fromwire_point32,
    towire_sha256,
    fromwire_sha256,
    towire_short_channel_id,
    fromwire_short_channel_id,
    towire_bip340sig,
    fromwire_bip340sig,
    towire_tu16,
    fromwire_tu16,
    towire_tu32,
    fromwire_tu32,
    towire_tu64,
    fromwire_tu64,
    towire_u16,
    fromwire_u16,
    towire_u32,
    fromwire_u32,
    towire_u64,
    fromwire_u64,
}=require('./fundamental_types')

// ~ Examples below,
// console.log(towire_offer_amount(['1000']))
// --> <Buffer 03 e8>

// console.log(fromwire_offer_amount(towire_offer_amount(['1000'])))
// --> [ '1000' ]

// console.log (towire_offer_description(['aditya']));
// --> <Buffer 61 64 69 74 79 61>

// console.log(fromwire_offer_description(towire_offer_description(['aditya'])));
// --> aditya

// console.log(towire_offer_node_id(['4b9a1fa8e006f1e3937f65f66c408e6da8e1ca728ea43222a7381df1cc449605']));
// --> <Buffer 4b 9a 1f a8 e0 06 f1 e3 93 7f 65 f6 6c 40 8e 6d a8 e1 ca 72 8e a4 32 22 a7 38 1d f1 cc 44 96 05> ~Will throw error if length is not appropriate(Point32)

// console.log(fromwire_offer_node_id(towire_offer_node_id(['4b9a1fa8e006f1e3937f65f66c408e6da8e1ca728ea43222a7381df1cc449605'])))
// --> [ '4b9a1fa8e006f1e3937f65f66c408e6da8e1ca728ea43222a7381df1cc449605' ] ~Will throw error if length is not appropriate(Point32)

//console.log(towire_tlv_payload_amt_to_forward(['100000000000000']))
// --> <Buffer 5a f3 10 7a 40 00>

// console.log(fromwire_tlv_payload_amt_to_forward(towire_tlv_payload_amt_to_forward(['100000000000000'])))
// --> [ '100000000000000' ]

function towire_tlv_payload_amt_to_forward(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"amt_to_forward": value}
    buf = Buffer.concat([buf, towire_tu64(value["amt_to_forward"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_tlv_payload_amt_to_forward(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["amt_to_forward"] = retarr[0];    buffer = retarr[1];

    return value["amt_to_forward"];
}

function towire_tlv_payload_outgoing_cltv_value(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"outgoing_cltv_value": value}
    buf = Buffer.concat([buf, towire_tu32(value["outgoing_cltv_value"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_tlv_payload_outgoing_cltv_value(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["outgoing_cltv_value"] = retarr[0];    buffer = retarr[1];

    return value["outgoing_cltv_value"];
}

function towire_tlv_payload_short_channel_id(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"short_channel_id": value}
    buf = Buffer.concat([buf, towire_short_channel_id(value["short_channel_id"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_tlv_payload_short_channel_id(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_short_channel_id(buffer);
    value["short_channel_id"] = retarr[0];    buffer = retarr[1];

    return value["short_channel_id"];
}

function towire_tlv_payload_payment_data(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert.equal(value["payment_secret"].length == 32)
    for (let v of value["payment_secret"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    buf = Buffer.concat([buf, towire_tu64(value["total_msat"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_tlv_payload_payment_data(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < 32; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["payment_secret"] = v;
    retarr = fromwire_tu64(buffer);
    value["total_msat"] = retarr[0];    buffer = retarr[1];

    return value;
}

const tlv_tlv_payload = {
    2: ["amt_to_forward", towire_tlv_payload_amt_to_forward, fromwire_tlv_payload_amt_to_forward],
    4: ["outgoing_cltv_value", towire_tlv_payload_outgoing_cltv_value, fromwire_tlv_payload_outgoing_cltv_value],
    6: ["short_channel_id", towire_tlv_payload_short_channel_id, fromwire_tlv_payload_short_channel_id],
    8: ["payment_data", towire_tlv_payload_payment_data, fromwire_tlv_payload_payment_data],
}
function towire_offer_chains(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"chains": value}
    for (let v of value["chains"]) {
        buf = Buffer.concat([buf, towire_chain_hash(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_chains(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_chain_hash(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["chains"] = v;

    return value["chains"];
}

function towire_offer_currency(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"iso4217": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["iso4217"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_currency(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["iso4217"] = retarr[0];
    buffer = retarr[1]

    return value["iso4217"];
}

function towire_offer_amount(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"amount": value}
    buf = Buffer.concat([buf, towire_tu64(value["amount"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_amount(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["amount"] = retarr[0];    buffer = retarr[1];

    return value["amount"];
}

function towire_offer_description(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"description": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["description"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_description(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["description"] = retarr[0];
    buffer = retarr[1]

    return value["description"];
}

function towire_offer_features(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"features": value}
    for (let v of value["features"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_features(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["features"] = v;

    return value["features"];
}

function towire_offer_absolute_expiry(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"seconds_from_epoch": value}
    buf = Buffer.concat([buf, towire_tu64(value["seconds_from_epoch"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_absolute_expiry(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["seconds_from_epoch"] = retarr[0];    buffer = retarr[1];

    return value["seconds_from_epoch"];
}

function towire_offer_paths(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"paths": value}
    for (let v of value["paths"]) {
        buf = Buffer.concat([buf, towire_blinded_path(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_paths(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_blinded_path(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["paths"] = v;

    return value["paths"];
}

function towire_offer_vendor(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"vendor": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["vendor"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_vendor(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["vendor"] = retarr[0];
    buffer = retarr[1]

    return value["vendor"];
}

function towire_offer_quantity_min(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"min": value}
    buf = Buffer.concat([buf, towire_tu64(value["min"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_quantity_min(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["min"] = retarr[0];    buffer = retarr[1];

    return value["min"];
}

function towire_offer_quantity_max(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"max": value}
    buf = Buffer.concat([buf, towire_tu64(value["max"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_quantity_max(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["max"] = retarr[0];    buffer = retarr[1];

    return value["max"];
}

function towire_offer_recurrence(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_byte(value["time_unit"])]);
    _n++;
    buf = Buffer.concat([buf, towire_tu32(value["period"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_recurrence(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_byte(buffer);
    value["time_unit"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_tu32(buffer);
    value["period"] = retarr[0];    buffer = retarr[1];

    return value;
}

function towire_offer_recurrence_paywindow(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_u32(value["seconds_before"])]);
    _n++;
    buf = Buffer.concat([buf, towire_byte(value["proportional_amount"])]);
    _n++;
    buf = Buffer.concat([buf, towire_tu32(value["seconds_after"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_recurrence_paywindow(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_u32(buffer);
    value["seconds_before"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_byte(buffer);
    value["proportional_amount"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_tu32(buffer);
    value["seconds_after"] = retarr[0];    buffer = retarr[1];

    return value;
}

function towire_offer_recurrence_limit(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"max_period": value}
    buf = Buffer.concat([buf, towire_tu32(value["max_period"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_recurrence_limit(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["max_period"] = retarr[0];    buffer = retarr[1];

    return value["max_period"];
}

function towire_offer_recurrence_base(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_byte(value["start_any_period"])]);
    _n++;
    buf = Buffer.concat([buf, towire_tu64(value["basetime"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_recurrence_base(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_byte(buffer);
    value["start_any_period"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_tu64(buffer);
    value["basetime"] = retarr[0];    buffer = retarr[1];

    return value;
}

function towire_offer_node_id(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"node_id": value}
    buf = Buffer.concat([buf, towire_point32(value["node_id"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_node_id(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point32(buffer);
    value["node_id"] = retarr[0];    buffer = retarr[1];

    return value["node_id"];
}

function towire_offer_send_invoice(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_send_invoice(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return value;
}

function towire_offer_refund_for(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"refunded_payment_hash": value}
    buf = Buffer.concat([buf, towire_sha256(value["refunded_payment_hash"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_refund_for(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["refunded_payment_hash"] = retarr[0];    buffer = retarr[1];

    return value["refunded_payment_hash"];
}

function towire_offer_signature(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"sig": value}
    buf = Buffer.concat([buf, towire_bip340sig(value["sig"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_offer_signature(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_bip340sig(buffer);
    value["sig"] = retarr[0];    buffer = retarr[1];

    return value["sig"];
}

const tlv_offer = {
    2: ["chains", towire_offer_chains, fromwire_offer_chains],
    6: ["currency", towire_offer_currency, fromwire_offer_currency],
    8: ["amount", towire_offer_amount, fromwire_offer_amount],
    10: ["description", towire_offer_description, fromwire_offer_description],
    12: ["features", towire_offer_features, fromwire_offer_features],
    14: ["absolute_expiry", towire_offer_absolute_expiry, fromwire_offer_absolute_expiry],
    16: ["paths", towire_offer_paths, fromwire_offer_paths],
    20: ["vendor", towire_offer_vendor, fromwire_offer_vendor],
    22: ["quantity_min", towire_offer_quantity_min, fromwire_offer_quantity_min],
    24: ["quantity_max", towire_offer_quantity_max, fromwire_offer_quantity_max],
    26: ["recurrence", towire_offer_recurrence, fromwire_offer_recurrence],
    64: ["recurrence_paywindow", towire_offer_recurrence_paywindow, fromwire_offer_recurrence_paywindow],
    66: ["recurrence_limit", towire_offer_recurrence_limit, fromwire_offer_recurrence_limit],
    28: ["recurrence_base", towire_offer_recurrence_base, fromwire_offer_recurrence_base],
    30: ["node_id", towire_offer_node_id, fromwire_offer_node_id],
    54: ["send_invoice", towire_offer_send_invoice, fromwire_offer_send_invoice],
    34: ["refund_for", towire_offer_refund_for, fromwire_offer_refund_for],
    240: ["signature", towire_offer_signature, fromwire_offer_signature],
}
function towire_invoice_request_chains(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"chains": value}
    for (let v of value["chains"]) {
        buf = Buffer.concat([buf, towire_chain_hash(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_chains(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_chain_hash(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["chains"] = v;

    return value["chains"];
}

function towire_invoice_request_offer_id(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"offer_id": value}
    buf = Buffer.concat([buf, towire_sha256(value["offer_id"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_offer_id(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["offer_id"] = retarr[0];    buffer = retarr[1];

    return value["offer_id"];
}

function towire_invoice_request_amount(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"msat": value}
    buf = Buffer.concat([buf, towire_tu64(value["msat"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_amount(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["msat"] = retarr[0];    buffer = retarr[1];

    return value["msat"];
}

function towire_invoice_request_features(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"features": value}
    for (let v of value["features"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_features(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["features"] = v;

    return value["features"];
}

function towire_invoice_request_quantity(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"quantity": value}
    buf = Buffer.concat([buf, towire_tu64(value["quantity"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_quantity(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["quantity"] = retarr[0];    buffer = retarr[1];

    return value["quantity"];
}

function towire_invoice_request_recurrence_counter(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"counter": value}
    buf = Buffer.concat([buf, towire_tu32(value["counter"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_recurrence_counter(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["counter"] = retarr[0];    buffer = retarr[1];

    return value["counter"];
}

function towire_invoice_request_recurrence_start(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"period_offset": value}
    buf = Buffer.concat([buf, towire_tu32(value["period_offset"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_recurrence_start(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["period_offset"] = retarr[0];    buffer = retarr[1];

    return value["period_offset"];
}

function towire_invoice_request_payer_key(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"key": value}
    buf = Buffer.concat([buf, towire_point32(value["key"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_payer_key(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point32(buffer);
    value["key"] = retarr[0];    buffer = retarr[1];

    return value["key"];
}

function towire_invoice_request_payer_note(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"note": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["note"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_payer_note(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["note"] = retarr[0];
    buffer = retarr[1]

    return value["note"];
}

function towire_invoice_request_payer_info(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"blob": value}
    for (let v of value["blob"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_payer_info(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["blob"] = v;

    return value["blob"];
}

function towire_invoice_request_replace_invoice(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"payment_hash": value}
    buf = Buffer.concat([buf, towire_sha256(value["payment_hash"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_replace_invoice(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["payment_hash"] = retarr[0];    buffer = retarr[1];

    return value["payment_hash"];
}

function towire_invoice_request_payer_signature(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"sig": value}
    buf = Buffer.concat([buf, towire_bip340sig(value["sig"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_request_payer_signature(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_bip340sig(buffer);
    value["sig"] = retarr[0];    buffer = retarr[1];

    return value["sig"];
}

const tlv_invoice_request = {
    2: ["chains", towire_invoice_request_chains, fromwire_invoice_request_chains],
    4: ["offer_id", towire_invoice_request_offer_id, fromwire_invoice_request_offer_id],
    8: ["amount", towire_invoice_request_amount, fromwire_invoice_request_amount],
    12: ["features", towire_invoice_request_features, fromwire_invoice_request_features],
    32: ["quantity", towire_invoice_request_quantity, fromwire_invoice_request_quantity],
    36: ["recurrence_counter", towire_invoice_request_recurrence_counter, fromwire_invoice_request_recurrence_counter],
    68: ["recurrence_start", towire_invoice_request_recurrence_start, fromwire_invoice_request_recurrence_start],
    38: ["payer_key", towire_invoice_request_payer_key, fromwire_invoice_request_payer_key],
    39: ["payer_note", towire_invoice_request_payer_note, fromwire_invoice_request_payer_note],
    50: ["payer_info", towire_invoice_request_payer_info, fromwire_invoice_request_payer_info],
    56: ["replace_invoice", towire_invoice_request_replace_invoice, fromwire_invoice_request_replace_invoice],
    240: ["payer_signature", towire_invoice_request_payer_signature, fromwire_invoice_request_payer_signature],
}
function towire_invoice_chains(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"chains": value}
    for (let v of value["chains"]) {
        buf = Buffer.concat([buf, towire_chain_hash(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_chains(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_chain_hash(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["chains"] = v;

    return value["chains"];
}

function towire_invoice_offer_id(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"offer_id": value}
    buf = Buffer.concat([buf, towire_sha256(value["offer_id"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_offer_id(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["offer_id"] = retarr[0];    buffer = retarr[1];

    return value["offer_id"];
}

function towire_invoice_amount(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"msat": value}
    buf = Buffer.concat([buf, towire_tu64(value["msat"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_amount(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["msat"] = retarr[0];    buffer = retarr[1];

    return value["msat"];
}

function towire_invoice_description(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"description": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["description"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_description(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["description"] = retarr[0];
    buffer = retarr[1]

    return value["description"];
}

function towire_invoice_features(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"features": value}
    for (let v of value["features"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_features(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["features"] = v;

    return value["features"];
}

function towire_invoice_paths(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"paths": value}
    for (let v of value["paths"]) {
        buf = Buffer.concat([buf, towire_blinded_path(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_paths(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_blinded_path(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["paths"] = v;

    return value["paths"];
}

function towire_invoice_blindedpay(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"payinfo": value}
    for (let v of value["payinfo"]) {
        buf = Buffer.concat([buf, towire_blinded_payinfo(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_blindedpay(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_blinded_payinfo(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["payinfo"] = v;

    return value["payinfo"];
}

function towire_invoice_blinded_capacities(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"incoming_msat": value}
    for (let v of value["incoming_msat"]) {
        buf = Buffer.concat([buf, towire_u64(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_blinded_capacities(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_u64(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["incoming_msat"] = v;

    return value["incoming_msat"];
}

function towire_invoice_vendor(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"vendor": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["vendor"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_vendor(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["vendor"] = retarr[0];
    buffer = retarr[1]

    return value["vendor"];
}

function towire_invoice_node_id(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"node_id": value}
    buf = Buffer.concat([buf, towire_point32(value["node_id"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_node_id(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point32(buffer);
    value["node_id"] = retarr[0];    buffer = retarr[1];

    return value["node_id"];
}

function towire_invoice_quantity(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"quantity": value}
    buf = Buffer.concat([buf, towire_tu64(value["quantity"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_quantity(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["quantity"] = retarr[0];    buffer = retarr[1];

    return value["quantity"];
}

function towire_invoice_refund_for(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"refunded_payment_hash": value}
    buf = Buffer.concat([buf, towire_sha256(value["refunded_payment_hash"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_refund_for(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["refunded_payment_hash"] = retarr[0];    buffer = retarr[1];

    return value["refunded_payment_hash"];
}

function towire_invoice_recurrence_counter(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"counter": value}
    buf = Buffer.concat([buf, towire_tu32(value["counter"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_recurrence_counter(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["counter"] = retarr[0];    buffer = retarr[1];

    return value["counter"];
}

function towire_invoice_send_invoice(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_send_invoice(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return value;
}

function towire_invoice_recurrence_start(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"period_offset": value}
    buf = Buffer.concat([buf, towire_tu32(value["period_offset"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_recurrence_start(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["period_offset"] = retarr[0];    buffer = retarr[1];

    return value["period_offset"];
}

function towire_invoice_recurrence_basetime(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"basetime": value}
    buf = Buffer.concat([buf, towire_tu64(value["basetime"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_recurrence_basetime(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["basetime"] = retarr[0];    buffer = retarr[1];

    return value["basetime"];
}

function towire_invoice_payer_key(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"key": value}
    buf = Buffer.concat([buf, towire_point32(value["key"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_payer_key(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point32(buffer);
    value["key"] = retarr[0];    buffer = retarr[1];

    return value["key"];
}

function towire_invoice_payer_note(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"note": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["note"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_payer_note(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["note"] = retarr[0];
    buffer = retarr[1]

    return value["note"];
}

function towire_invoice_payer_info(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"blob": value}
    for (let v of value["blob"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_payer_info(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["blob"] = v;

    return value["blob"];
}

function towire_invoice_created_at(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"timestamp": value}
    buf = Buffer.concat([buf, towire_tu64(value["timestamp"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_created_at(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["timestamp"] = retarr[0];    buffer = retarr[1];

    return value["timestamp"];
}

function towire_invoice_payment_hash(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"payment_hash": value}
    buf = Buffer.concat([buf, towire_sha256(value["payment_hash"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_payment_hash(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["payment_hash"] = retarr[0];    buffer = retarr[1];

    return value["payment_hash"];
}

function towire_invoice_relative_expiry(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"seconds_from_creation": value}
    buf = Buffer.concat([buf, towire_tu32(value["seconds_from_creation"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_relative_expiry(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["seconds_from_creation"] = retarr[0];    buffer = retarr[1];

    return value["seconds_from_creation"];
}

function towire_invoice_cltv(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"min_final_cltv_expiry": value}
    buf = Buffer.concat([buf, towire_tu32(value["min_final_cltv_expiry"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_cltv(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu32(buffer);
    value["min_final_cltv_expiry"] = retarr[0];    buffer = retarr[1];

    return value["min_final_cltv_expiry"];
}

function towire_invoice_fallbacks(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_byte(value["fallbacks"].length)]);

    _n++;
    for (let v of value["fallbacks"]) {
        buf = Buffer.concat([buf, towire_fallback_address(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_fallbacks(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_byte(buffer);
    let lenfield_num = retarr[0];
    buffer = retarr[1];
    v = [];
    for (let i = 0; i < lenfield_num; i++) {
        retarr = fromwire_fallback_address(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["fallbacks"] = v;

    return value;
}

function towire_invoice_refund_signature(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"payer_signature": value}
    buf = Buffer.concat([buf, towire_bip340sig(value["payer_signature"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_refund_signature(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_bip340sig(buffer);
    value["payer_signature"] = retarr[0];    buffer = retarr[1];

    return value["payer_signature"];
}

function towire_invoice_replace_invoice(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"payment_hash": value}
    buf = Buffer.concat([buf, towire_sha256(value["payment_hash"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_replace_invoice(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["payment_hash"] = retarr[0];    buffer = retarr[1];

    return value["payment_hash"];
}

function towire_invoice_signature(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"sig": value}
    buf = Buffer.concat([buf, towire_bip340sig(value["sig"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_signature(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_bip340sig(buffer);
    value["sig"] = retarr[0];    buffer = retarr[1];

    return value["sig"];
}

const tlv_invoice = {
    2: ["chains", towire_invoice_chains, fromwire_invoice_chains],
    4: ["offer_id", towire_invoice_offer_id, fromwire_invoice_offer_id],
    8: ["amount", towire_invoice_amount, fromwire_invoice_amount],
    10: ["description", towire_invoice_description, fromwire_invoice_description],
    12: ["features", towire_invoice_features, fromwire_invoice_features],
    16: ["paths", towire_invoice_paths, fromwire_invoice_paths],
    18: ["blindedpay", towire_invoice_blindedpay, fromwire_invoice_blindedpay],
    19: ["blinded_capacities", towire_invoice_blinded_capacities, fromwire_invoice_blinded_capacities],
    20: ["vendor", towire_invoice_vendor, fromwire_invoice_vendor],
    30: ["node_id", towire_invoice_node_id, fromwire_invoice_node_id],
    32: ["quantity", towire_invoice_quantity, fromwire_invoice_quantity],
    34: ["refund_for", towire_invoice_refund_for, fromwire_invoice_refund_for],
    36: ["recurrence_counter", towire_invoice_recurrence_counter, fromwire_invoice_recurrence_counter],
    54: ["send_invoice", towire_invoice_send_invoice, fromwire_invoice_send_invoice],
    68: ["recurrence_start", towire_invoice_recurrence_start, fromwire_invoice_recurrence_start],
    64: ["recurrence_basetime", towire_invoice_recurrence_basetime, fromwire_invoice_recurrence_basetime],
    38: ["payer_key", towire_invoice_payer_key, fromwire_invoice_payer_key],
    39: ["payer_note", towire_invoice_payer_note, fromwire_invoice_payer_note],
    50: ["payer_info", towire_invoice_payer_info, fromwire_invoice_payer_info],
    40: ["created_at", towire_invoice_created_at, fromwire_invoice_created_at],
    42: ["payment_hash", towire_invoice_payment_hash, fromwire_invoice_payment_hash],
    44: ["relative_expiry", towire_invoice_relative_expiry, fromwire_invoice_relative_expiry],
    46: ["cltv", towire_invoice_cltv, fromwire_invoice_cltv],
    48: ["fallbacks", towire_invoice_fallbacks, fromwire_invoice_fallbacks],
    52: ["refund_signature", towire_invoice_refund_signature, fromwire_invoice_refund_signature],
    56: ["replace_invoice", towire_invoice_replace_invoice, fromwire_invoice_replace_invoice],
    240: ["signature", towire_invoice_signature, fromwire_invoice_signature],
}
function towire_invoice_error_erroneous_field(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"tlv_fieldnum": value}
    buf = Buffer.concat([buf, towire_tu64(value["tlv_fieldnum"])]);
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_error_erroneous_field(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_tu64(buffer);
    value["tlv_fieldnum"] = retarr[0];    buffer = retarr[1];

    return value["tlv_fieldnum"];
}

function towire_invoice_error_suggested_value(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"value": value}
    for (let v of value["value"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_error_suggested_value(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    v = [];
    for (let i = 0; i < buffer.length; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["value"] = v;

    return value["value"];
}

function towire_invoice_error_error(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    value = {"msg": value}
    buf = Buffer.concat([buf, towire_array_utf8(value["msg"])]);

    _n++;
    assert(Object.keys(value).length == _n);
    return buf;
}

function fromwire_invoice_error_error(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_array_utf8(buffer, buffer.length);
    value["msg"] = retarr[0];
    buffer = retarr[1]

    return value["msg"];
}

const tlv_invoice_error = {
    1: ["erroneous_field", towire_invoice_error_erroneous_field, fromwire_invoice_error_erroneous_field],
    3: ["suggested_value", towire_invoice_error_suggested_value, fromwire_invoice_error_suggested_value],
    5: ["error", towire_invoice_error_error, fromwire_invoice_error_error],
}
function towire_onionmsg_path(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_point(value["node_id"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u16(value["enctlv"].length)]);

    _n++;
    for (let v of value["enctlv"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_onionmsg_path(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point(buffer);
    value["node_id"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u16(buffer);
    let lenfield_enclen = retarr[0];
    buffer = retarr[1];
    v = [];
    for (let i = 0; i < lenfield_enclen; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["enctlv"] = v;

    return [value, buffer];
}

function towire_blinded_path(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_point(value["blinding"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u16(value["path"].length)]);

    _n++;
    for (let v of value["path"]) {
        buf = Buffer.concat([buf, towire_onionmsg_path(v)]);
    }
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_blinded_path(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_point(buffer);
    value["blinding"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u16(buffer);
    let lenfield_num_hops = retarr[0];
    buffer = retarr[1];
    v = [];
    for (let i = 0; i < lenfield_num_hops; i++) {
        retarr = fromwire_onionmsg_path(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["path"] = v;

    return [value, buffer];
}

function towire_blinded_payinfo(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_u32(value["fee_base_msat"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u32(value["fee_proportional_millionths"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u16(value["cltv_expiry_delta"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u16(value["features"].length)]);

    _n++;
    for (let v of value["features"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_blinded_payinfo(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_u32(buffer);
    value["fee_base_msat"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u32(buffer);
    value["fee_proportional_millionths"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u16(buffer);
    value["cltv_expiry_delta"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u16(buffer);
    let lenfield_flen = retarr[0];
    buffer = retarr[1];
    v = [];
    for (let i = 0; i < lenfield_flen; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["features"] = v;

    return [value, buffer];
}

function towire_fallback_address(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_byte(value["version"])]);
    _n++;
    buf = Buffer.concat([buf, towire_u16(value["address"].length)]);

    _n++;
    for (let v of value["address"]) {
        buf = Buffer.concat([buf, towire_byte(v)]);
    }
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_fallback_address(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_byte(buffer);
    value["version"] = retarr[0];    buffer = retarr[1];
    retarr = fromwire_u16(buffer);
    let lenfield_len = retarr[0];
    buffer = retarr[1];
    v = [];
    for (let i = 0; i < lenfield_len; i++) {
        retarr = fromwire_byte(buffer);
        v.push(retarr[0]);
        buffer = retarr[1];
    }
    value["address"] = v;

    return [value, buffer];
}

function towire_invalid_realm(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(value.length == _n);
    return buf;
}

function fromwire_invalid_realm(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return [value, buffer];
}

function towire_temporary_node_failure(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(value.length == _n);
    return buf;
}

function fromwire_temporary_node_failure(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return [value, buffer];
}

function towire_permanent_node_failure(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(value.length == _n);
    return buf;
}

function fromwire_permanent_node_failure(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return [value, buffer];
}

function towire_required_node_feature_missing(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    assert(value.length == _n);
    return buf;
}

function fromwire_required_node_feature_missing(buffer)
{
    let _n = 0;
    let retarr;
    value = {};

    return [value, buffer];
}

function towire_invalid_onion_version(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_sha256(value["sha256_of_onion"])]);
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_invalid_onion_version(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["sha256_of_onion"] = retarr[0];    buffer = retarr[1];

    return [value, buffer];
}

function towire_invalid_onion_hmac(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_sha256(value["sha256_of_onion"])]);
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_invalid_onion_hmac(buffer)
{
    let _n = 0;
    let retarr;
    value = {};
    retarr = fromwire_sha256(buffer);
    value["sha256_of_onion"] = retarr[0];    buffer = retarr[1];

    return [value, buffer];
}

function towire_invalid_onion_key(value)
{
    let _n = 0;
    let buf = Buffer.alloc(0);
    buf = Buffer.concat([buf, towire_sha256(value["sha256_of_onion"])]);
    _n++;
    assert(value.length == _n);
    return buf;
}

function fromwire_invalid_onion_key(buffer