Function generate_gossip_store

tests/utils.py:513–614

Returns a gossip store file with the given channels in it, and a map of node labels -> ids

(channels, nodemap={})

def generate_gossip_store(channels, nodemap={}):
    """Returns a gossip store file with the given channels in it, and a map of node labels -> ids
    """
    nodes = []

    def write_bignum(outf, val):
        if val < 253:
            outf.write(val.to_bytes(1, byteorder='big'))
        elif val <= 0xFFFF:
            outf.write(b'\xFD')
            outf.write(val.to_bytes(2, byteorder='big'))
        elif val <= 0xFFFFFFFF:
            outf.write(b'\xFE')
            outf.write(val.to_bytes(4, byteorder='big'))
        else:
            outf.write(b'\xFF')
            outf.write(val.to_bytes(8, byteorder='big'))

    def write_dumb_template(outf, channels, propname, illegalvals=[]):
        """We don't bother uniquifing, just one entry per chan dir"""
        # Template is simply all the values
        write_bignum(outf, len(channels) * 2)
        for c in channels:
            for d in (0, 1):
                v = getattr(c.half[d], propname)
                assert v not in illegalvals
                write_bignum(outf, v)

        # Now each entry for each channel half points into the values.
        for i in range(0, len(channels) * 2):
            write_bignum(outf, i)

    # First create nodes
    for c in channels:
        if c.node1 not in nodes:
            nodes.append(c.node1)
        if c.node2 not in nodes:
            nodes.append(c.node2)

    cfile = tempfile.NamedTemporaryFile(prefix='gs-compressed-')
    # <HEADER> := "GOSSMAP_COMPRESSv1\0"
    cfile.write(b'GOSSMAP_COMPRESSv1\x00')
    # <CHANNEL_ENDS> := {channel_count} {start_nodeidx}*{channel_count} {end_nodeidx}*{channel_count}
    write_bignum(cfile, len(channels))
    for c in channels:
        write_bignum(cfile, nodes.index(c.node1))
    for c in channels:
        write_bignum(cfile, nodes.index(c.node2))

    # <DISABLEDS> := <DISABLED>* {channel_count*2}
    # <DISABLED> := {chanidx}*2+{direction}
    for i, c in enumerate(channels):
        for d in (0, 1):
            if not c.half[d].enabled:
                write_bignum(cfile, i * 2 + d)
    write_bignum(cfile, len(channels) * 2)

    # <CAPACITIES> := <CAPACITY_TEMPLATES> {channel_count}*{capacity_idx}