from collections import OrderedDict

from datetime import datetime

from fixtures import * # noqa: F401,F403

from hashlib import sha256

from pyln.client import RpcError, Millisatoshi

from pyln.proto import Invoice

from pyln.testing.utils import FUNDAMOUNT

from utils import (

only_one, sync_blockheight, TIMEOUT, wait_for, TEST_NETWORK,

expected_peer_features, expected_node_features,

expected_channel_features, account_balance,

check_coin_moves, first_channel_id, EXPERIMENTAL_DUAL_FUND,

mine_funding_to_announce, VALGRIND, first_scid

)

import ast

import json

import os

import pytest

import random

import re

import signal

import sqlite3

import stat

import subprocess

import sys

import time

import unittest

def test_option_passthrough(node_factory, directory):

""" Ensure that registering options works.

First attempts without the plugin and then with the plugin.

Then a plugin tries to register the same option "name" again, fails startup.

"""

plugin_path = os.path.join(os.getcwd(), 'contrib/plugins/helloworld.py')

plugin_path2 = os.path.join(os.getcwd(), 'tests/plugins/options.py')

help_out = subprocess.check_output([

'lightningd/lightningd',

'--lightning-dir={}'.format(directory),

'--help'

]).decode('utf-8')

assert('--greeting' not in help_out)

help_out = subprocess.check_output([

'lightningd/lightningd',

'--lightning-dir={}'.format(directory),

'--plugin={}'.format(plugin_path),

'--help'

]).decode('utf-8')

assert('--greeting' in help_out)

# Now try to see if it gets accepted, would fail to start if the

# option didn't exist

n = node_factory.get_node(options={'plugin': plugin_path, 'greeting': 'Ciao'})

n.stop()

with pytest.raises(subprocess.CalledProcessError):

err_out = subprocess.run([

'lightningd/lightningd',

'--lightning-dir={}'.format(directory),

'--plugin={}'.format(plugin_path),

'--plugin={}'.format(plugin_path2),

'--help'

], capture_output=True, check=True).stderr.decode('utf-8')

# first come first serve

assert("error starting plugin '{}': option name 'greeting' is already taken".format(plugin_path2) in err_out)

def test_option_types(node_factory):

"""Ensure that desired types of options are

respected in output """

plugin_path = os.path.join(os.getcwd(), 'tests/plugins/options.py')

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_opt': 'ok',

'int_opt': 22,

'bool_opt': True,

})

assert n.daemon.is_in_log(r"option str_opt ok <class 'str'>")

assert n.daemon.is_in_log(r"option int_opt 22 <class 'int'>")

assert n.daemon.is_in_log(r"option bool_opt True <class 'bool'>")

# flag options aren't passed through if not flagged on

assert not n.daemon.is_in_log(r"option flag_opt")

n.stop()

# A blank bool_opt should default to false

n = node_factory.get_node(options={

'plugin': plugin_path, 'str_opt': 'ok',

'int_opt': 22,

'bool_opt': 'true',

'flag_opt': None,

})

assert n.daemon.is_in_log(r"option bool_opt True <class 'bool'>")

assert n.daemon.is_in_log(r"option flag_opt True <class 'bool'>")

n.stop()

# What happens if we give it a bad bool-option?

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_opt': 'ok',

'int_opt': 22,

'bool_opt': '!',

}, may_fail=True, start=False)

# the node should fail after start, and we get a stderr msg

n.daemon.start(wait_for_initialized=False, stderr_redir=True)

assert n.daemon.wait() == 1

wait_for(lambda: n.daemon.is_in_stderr("--bool_opt=!: Invalid argument '!'"))

# What happens if we give it a bad int-option?

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_opt': 'ok',

'int_opt': 'notok',

'bool_opt': True,

}, may_fail=True, start=False)

# the node should fail after start, and we get a stderr msg

n.daemon.start(wait_for_initialized=False, stderr_redir=True)

assert n.daemon.wait() == 1

assert n.daemon.is_in_stderr("--int_opt=notok: 'notok' is not a number")

# We no longer allow '1' or '0' as boolean options

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_opt': 'ok',

'bool_opt': '1',

}, may_fail=True, start=False)

# the node should fail after start, and we get a stderr msg

n.daemon.start(wait_for_initialized=False, stderr_redir=True)

assert n.daemon.wait() == 1

assert n.daemon.is_in_stderr("--bool_opt=1: Invalid argument '1'")

# Flag opts shouldn't allow any input

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_opt': 'ok',

'int_opt': 11,

'bool_opt': True,

'flag_opt': True,

}, may_fail=True, start=False)

# the node should fail after start, and we get a stderr msg

n.daemon.start(wait_for_initialized=False, stderr_redir=True)

assert n.daemon.wait() == 1

assert n.daemon.is_in_stderr("--flag_opt=True: doesn't allow an argument")

n = node_factory.get_node(options={

'plugin': plugin_path,

'str_optm': ['ok', 'ok2'],

'int_optm': [11, 12, 13],

})

assert n.daemon.is_in_log(r"option str_optm \['ok', 'ok2'\] <class 'list'>")

assert n.daemon.is_in_log(r"option int_optm \[11, 12, 13\] <class 'list'>")

n.stop()

def test_millisatoshi_passthrough(node_factory):

""" Ensure that Millisatoshi arguments and return work.

"""

plugin_path = os.path.join(os.getcwd(), 'tests/plugins/millisatoshis.py')

n = node_factory.get_node(options={'plugin': plugin_path, 'log-level': 'io'})

# By keyword (plugin literally returns Millisatoshi, which becomes a string)

ret = n.rpc.call('echo', {'msat': Millisatoshi(17), 'not_an_msat': '22msat'})['echo_msat']

assert Millisatoshi(ret) == Millisatoshi(17)

# By position

ret = n.rpc.call('echo', [Millisatoshi(18), '22msat'])['echo_msat']

assert Millisatoshi(ret) == Millisatoshi(18)

def test_rpc_passthrough(node_factory):

"""Starting with a plugin exposes its RPC methods.

First check that the RPC method appears in the help output and

then try to call it.

"""

plugin_path = os.path.join(os.getcwd(), 'contrib/plugins/helloworld.py')

n = node_factory.get_node(options={'plugin': plugin_path, 'greeting': 'Ciao'})

# Make sure that the 'hello' command that the helloworld.py plugin

# has registered is available.

cmd = [hlp for hlp in n.rpc.help()['help'] if 'hello' in hlp['command']]

assert(len(cmd) == 1)

# Make sure usage message is present.

assert only_one(n.rpc.help('hello')['help'])['command'].startswith('hello [name]')

# While we're at it, let's check that helloworld.py is logging

# correctly via the notifications plugin->lightningd

assert n.daemon.is_in_log('Plugin helloworld.py initialized')

# Now try to call it and see what it returns:

greet = n.rpc.hello(name='World')

assert(greet == "Ciao World")

with pytest.raises(RpcError):

n.rpc.fail()

# Try to call a method without enough arguments

with pytest.raises(RpcError, match="processing bye: missing a required"

" argument"):

n.rpc.bye()

def test_plugin_dir(node_factory):

"""--plugin-dir works"""

plugin_dir = os.path.join(os.getcwd(), 'contrib/plugins')

node_factory.get_node(options={'plugin-dir': plugin_dir, 'greeting': 'Mars'})

def test_plugin_slowinit(node_factory):

"""Tests that the 'plugin' RPC command times out if plugin doesnt respond"""

os.environ['SLOWINIT_TIME'] = '121'

n = node_factory.get_node()

with pytest.raises(RpcError, match=': timed out before replying to init'):

n.rpc.plugin_start(os.path.join(os.getcwd(), "tests/plugins/slow_init.py"))

# It's not actually configured yet, see what happens;

# make sure 'rescan' and 'list' controls dont crash

n.rpc.plugin_rescan()

n.rpc.plugin_list()

def test_plugin_command(node_factory):

"""Tests the 'plugin' RPC command"""

n = node_factory.get_node()

# Make sure that the 'hello' command from the helloworld.py plugin

# is not available.

cmd = [hlp for hlp in n.rpc.help()["help"] if "hello" in hlp["command"]]

assert(len(cmd) == 0)

# Add the 'contrib/plugins' test dir

n.rpc.plugin_startdir(directory=os.path.join(os.getcwd(), "contrib/plugins"))

# Make sure that the 'hello' command from the helloworld.py plugin

# is now available.

cmd = [hlp for hlp in n.rpc.help()["help"] if "hello" in hlp["command"]]

assert(len(cmd) == 1)

# Make sure 'rescan' and 'list' subcommands dont crash

n.rpc.plugin_rescan()

n.rpc.plugin_list()

# Make sure the plugin behaves normally after stop and restart

assert("Successfully stopped helloworld.py."

== n.rpc.plugin_stop(plugin="helloworld.py")["result"])

n.daemon.wait_for_log(r"Killing plugin: stopped by lightningd via RPC")

n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), "contrib/plugins/helloworld.py"))

n.daemon.wait_for_log(r"Plugin helloworld.py initialized")

assert("Hello world" == n.rpc.call(method="hello"))

# Now stop the helloworld plugin

assert("Successfully stopped helloworld.py."

== n.rpc.plugin_stop(plugin="helloworld.py")["result"])

n.daemon.wait_for_log(r"Killing plugin: stopped by lightningd via RPC")

# Make sure that the 'hello' command from the helloworld.py plugin

# is not available anymore.

cmd = [hlp for hlp in n.rpc.help()["help"] if "hello" in hlp["command"]]

assert(len(cmd) == 0)

# Test that we cannot start a plugin with 'dynamic' set to False in

# getmanifest

with pytest.raises(RpcError, match=r"Not a dynamic plugin"):

n.rpc.plugin_start(plugin=os.path.join(os.getcwd(), "tests/plugins/static.py"))

# Test that we cannot stop a started plugin with 'dynamic' flag set to

# False

n2 = node_factory.get_node(options={

"plugin": os.path.join(os.getcwd(), "tests/plugins/static.py")

})

with pytest.raises(RpcError, match=r"static.py cannot be managed when lightningd is up"):

n2.rpc.plugin_stop(plugin="static.py")

# Test that we don't crash when starting a broken plugin

with pytest.raises(RpcError, match=r": exited before replying to getmanifest"):

n2.rpc.plugin_start(plugin=os.path.join(os.getcwd(), "tests/plugins/broken.py"))

with pytest.raises(RpcError, match=r': timed out before replying to getmanifest'):

n2.rpc.plugin_start(os.path.join(os.getcwd(), 'contrib/plugins/fail/failtimeout.py'))

# Test that we can add a directory with more than one new plugin in it.

try:

n.rpc.plugin_startdir(os.path.join(os.getcwd(), "contrib/plugins"))

except RpcError:

pass

# Usually, it crashes after the above return.

n.rpc.stop()

def test_plugin_fail_on_startup(node_factory):

for crash in ('during_init', 'before_start', 'during_getmanifest'):

os.environ['BROKEN_CRASH'] = crash

n = node_factory.get_node(options={'plugin': os.path.join(os.getcwd(), "tests/plugins/broken.py")})

# This can happen before 'Server started with public key' msg

n.daemon.logsearch_start = 0

n.daemon.wait_for_log('plugin-broken.py: Traceback')

# Make sure they don't die *after* the message!

time.sleep(30)

def test_plugin_disable(node_factory):

"""--disable-plugin works"""

plugin_dir = os.path.join(os.getcwd(), 'contrib/plugins')

# We used to need plugin-dir before disable-plugin!

n = node_factory.get_node(options=OrderedDict([('plugin-dir', plugin_dir),

('disable-plugin',

'{}/helloworld.py'

.format(plugin_dir))]))

with pytest.raises(RpcError):

n.rpc.hello(name='Sun')

assert n.daemon.is_in_log('helloworld.py: disabled via disable-plugin')

n.stop()

# Also works by basename.

n = node_factory.get_node(options=OrderedDict([('plugin-dir', plugin_dir),

('disable-plugin',

'helloworld.py')]))

with pytest.raises(RpcError):

n.rpc.hello(name='Sun')

assert n.daemon.is_in_log('helloworld.py: disabled via disable-plugin')

n.stop()

# Other order also works!

n = node_factory.get_node(options=OrderedDict([('disable-plugin',

'helloworld.py'),

('plugin-dir', plugin_dir)]))

with pytest.raises(RpcError):

n.rpc.hello(name='Sun')

assert n.daemon.is_in_log('helloworld.py: disabled via disable-plugin')

n.stop()

# Both orders of explicit specification work.

n = node_factory.get_node(options=OrderedDict([('disable-plugin',

'helloworld.py'),

('plugin',

'{}/helloworld.py'

.format(plugin_dir))]))

with pytest.raises(RpcError):

n.rpc.hello(name='Sun')

assert n.daemon.is_in_log('helloworld.py: disabled via disable-plugin')

n.stop()

# Both orders of explicit specification work.

n = node_factory.get_node(options=OrderedDict([('plugin',

'{}/helloworld.py'

.format(plugin_dir)),

('disable-plugin',

'helloworld.py')]))

with pytest.raises(RpcError):

n.rpc.hello(name='Sun')

assert n.daemon.is_in_log('helloworld.py: disabled via disable-plugin')

# Still disabled if we load directory.

n.rpc.plugin_startdir(directory=os.path.join(os.getcwd(), "contrib/plugins"))

n.daemon.wait_for_log('helloworld.py: disabled via disable-plugin')

n.stop()

# Check that list works

n = node_factory.get_node(options={'disable-plugin':

['something-else.py', 'helloworld.py']})

assert n.rpc.listconfigs()['configs']['disable-plugin'] == {'values_str': ['something-else.py', 'helloworld.py'], 'sources': ['cmdline', 'cmdline']}

def test_plugin_hook(node_factory, executor):

"""The helloworld plugin registers a htlc_accepted hook.

The hook will sleep for a few seconds and log a

message. `lightningd` should wait for the response and only then

complete the payment.

"""

l1, l2 = node_factory.line_graph(2, opts={'plugin': os.path.join(os.getcwd(), 'contrib/plugins/helloworld.py')})

start_time = time.time()

f = executor.submit(l1.pay, l2, 100000)

l2.daemon.wait_for_log(r'on_htlc_accepted called')

# The hook will sleep for 20 seconds before answering, so `f`

# should take at least that long.

f.result()

end_time = time.time()

assert(end_time >= start_time + 20)

def test_plugin_connect_notifications(node_factory):

""" test 'connect' and 'disconnect' notifications

"""

l1, l2 = node_factory.get_nodes(2, opts={'plugin': os.path.join(os.getcwd(), 'contrib/plugins/helloworld.py')})

l1.connect(l2)

l1.daemon.wait_for_log(r'Received connect event')

l2.daemon.wait_for_log(r'Received connect event')

l2.rpc.disconnect(l1.info['id'])

l1.daemon.wait_for_log(r'Received disconnect event')

l2.daemon.wait_for_log(r'Received disconnect event')

def test_failing_plugins(directory):

fail_plugins = [

os.path.join(os.getcwd(), 'contrib/plugins/fail/failtimeout.py'),

os.path.join(os.getcwd(), 'contrib/plugins/fail/doesnotexist.py'),

]

for p in fail_plugins:

with pytest.raises(subprocess.CalledProcessError):

subprocess.check_output([

'lightningd/lightningd',

'--lightning-dir={}'.format(directory),

'--plugin={}'.format(p),

'--help',

])

def test_pay_plugin(node_factory):

l1, l2 = node_factory.line_graph(2)

inv = l2.rpc.invoice(123000, 'label', 'description', 3700)

res = l1.rpc.pay(bolt11=inv['bolt11'])

assert res['status'] == 'complete'

with pytest.raises(RpcError, match=r'missing required parameter'):

l1.rpc.call('pay')

# Make sure usage messages are present.

msg = 'pay bolt11 [amount_msat] [label] [riskfactor] [maxfeepercent] '\

'[retry_for] [maxdelay] [exemptfee] [localinvreqid] [exclude] '\

'[maxfee] [description] [partial_msat]'

# We run with --developer:

msg += ' [dev_use_shadow]'

assert only_one(l1.rpc.help('pay')['help'])['command'] == msg

def test_keysend_plugin(node_factory):

l1, l2 = node_factory.line_graph(2)

with pytest.raises(RpcError, match=r'missing required parameter'):

l1.rpc.call('keysend')

# Make sure usage messages are present.

msg = 'keysend destination amount_msat [label] [maxfeepercent] [retry_for] '\

'[maxdelay] [exemptfee] [extratlvs] [routehints] [maxfee]'

# We run with --developer:

msg += ' [dev_use_shadow]'

assert only_one(l1.rpc.help('keysend')['help'])['command'] == msg

def test_plugin_connected_hook_chaining(node_factory):

""" l1 uses the logger_a, reject and logger_b plugin.

l1 is configured to accept connections from l2, but not from l3.

we check that logger_a is always called and logger_b only for l2.

"""

opts = [{'plugin':

[os.path.join(os.getcwd(),

'tests/plugins/peer_connected_logger_a.py'),

os.path.join(os.getcwd(),

'tests/plugins/reject.py'),

os.path.join(os.getcwd(),

'tests/plugins/peer_connected_logger_b.py')],

'allow_warning': True},

{},

{'allow_warning': True}]

l1, l2, l3 = node_factory.get_nodes(3, opts=opts)

l2id = l2.info['id']

l3id = l3.info['id']

l1.rpc.reject(l3.info['id'])

l2.connect(l1)

l1.daemon.wait_for_logs([

f"peer_connected_logger_a {l2id}",

f"{l2id} is allowed",

f"peer_connected_logger_b {l2id}"

])

assert len(l1.rpc.listpeers(l2id)['peers']) == 1

# If reject happens fast enough, connect fails with "disconnected

# during connection"

try:

l3.connect(l1)

except RpcError as err:

assert "disconnected during connection" in err.error['message']

l1.daemon.wait_for_logs([

f"peer_connected_logger_a {l3id}",

f"{l3id} is in reject list"

])

# FIXME: this error occurs *after* connection, so we connect then drop.

l3.daemon.wait_for_log(r"-connectd: peer_in WIRE_WARNING")

l3.daemon.wait_for_log(r"You are in reject list")

def check_disconnect():

peers = l1.rpc.listpeers(l3id)['peers']

return peers == [] or not peers[0]['connected']

wait_for(check_disconnect)

assert not l1.daemon.is_in_log(f"peer_connected_logger_b {l3id}")

def test_peer_connected_remote_addr(node_factory):

"""This tests the optional tlv `remote_addr` being passed to a plugin.

The optional tlv `remote_addr` should only be visible to the initiator l1.

"""

pluginpath = os.path.join(os.getcwd(), 'tests/plugins/peer_connected_logger_a.py')

l1, l2 = node_factory.get_nodes(2, opts={

'plugin': pluginpath,

'dev-allow-localhost': None})

l1id = l1.info['id']

l2id = l2.info['id']

l1.connect(l2)

l1log = l1.daemon.wait_for_log(f"peer_connected_logger_a {l2id}")

l2log = l2.daemon.wait_for_log(f"peer_connected_logger_a {l1id}")

# the log entries are followed by the peer_connected payload as dict {} like:

# {'id': '022d223...', 'direction': 'out', 'addr': '127.0.0.1:35289',

# 'remote_addr': '127.0.0.1:59582', 'features': '8808226aa2'}

l1payload = eval(l1log[l1log.find('{'):])

l2payload = eval(l2log[l2log.find('{'):])

# check that l1 sees its remote_addr as l2 sees l1

assert(l1payload['remote_addr'] == l2payload['addr'])

assert(not l2payload.get('remote_addr')) # l2 can't see a remote_addr

def test_async_rpcmethod(node_factory, executor):

"""This tests the async rpcmethods.

It works in conjunction with the `asynctest` plugin which stashes

requests and then resolves all of them on the fifth call.

"""

l1 = node_factory.get_node(options={'plugin': os.path.join(os.getcwd(), 'tests/plugins/asynctest.py')})

results = []

for i in range(10):

results.append(executor.submit(l1.rpc.asyncqueue))

time.sleep(3)

# None of these should have returned yet

assert len([r for r in results if r.done()]) == 0

# This last one triggers the release and all results should be 42,

# since the last number is returned for all

l1.rpc.asyncflush(42)

assert [r.result() for r in results] == [42] * len(results)

@unittest.skipIf(os.getenv('TEST_DB_PROVIDER', 'sqlite3') != 'sqlite3', "Only sqlite3 implements the db_write_hook currently")

def test_db_hook(node_factory, executor):

"""This tests the db hook."""

dbfile = os.path.join(node_factory.directory, "dblog.sqlite3")

l1 = node_factory.get_node(options={'plugin': os.path.join(os.getcwd(), 'tests/plugins/dblog.py'),

'dblog-file': dbfile})

# It should see the db being created, and sometime later actually get

# initted.

# This precedes startup, so needle already past

assert l1.daemon.is_in_log(r'plugin-dblog.py: deferring \d+ commands')

l1.daemon.logsearch_start = 0

l1.daemon.wait_for_log('plugin-dblog.py: replaying pre-init data:')

l1.daemon.wait_for_log('plugin-dblog.py: CREATE TABLE version \\(version INTEGER\\)')

l1.daemon.wait_for_log("plugin-dblog.py: initialized.* 'startup': True")

l1.stop()

# Databases should be identical.

db1 = sqlite3.connect(os.path.join(l1.daemon.lightning_dir, TEST_NETWORK, 'lightningd.sqlite3'))

db2 = sqlite3.connect(dbfile)

assert [x for x in db1.iterdump()] == [x for x in db2.iterdump()]

@unittest.skipIf(os.getenv('TEST_DB_PROVIDER', 'sqlite3') != 'sqlite3', "Only sqlite3 implements the db_write_hook currently")

def test_db_hook_multiple(node_factory, executor):

"""This tests the db hook for multiple-plugin case."""

dbfile = os.path.join(node_factory.directory, "dblog.sqlite3")

l1 = node_factory.get_node(options={'plugin': os.path.join(os.getcwd(), 'tests/plugins/dblog.py'),

'important-plugin': os.path.join(os.getcwd(), 'tests/plugins/dbdummy.py'),

'dblog-file': dbfile})

# It should see the db being created, and sometime later actually get

# initted.

# This precedes startup, so needle already past

assert l1.daemon.is_in_log(r'plugin-dblog.py: deferring \d+ commands')

l1.daemon.logsearch_start = 0

l1.daemon.wait_for_log('plugin-dblog.py: replaying pre-init data:')

l1.daemon.wait_for_log('plugin-dblog.py: CREATE TABLE version \\(version INTEGER\\)')

l1.daemon.wait_for_log("plugin-dblog.py: initialized.* 'startup': True")

l1.stop()

# Databases should be identical.

db1 = sqlite3.connect(os.path.join(l1.daemon.lightning_dir, TEST_NETWORK, 'lightningd.sqlite3'))

db2 = sqlite3.connect(dbfile)

assert [x for x in db1.iterdump()] == [x for x in db2.iterdump()]

def test_utf8_passthrough(node_factory, executor):

l1 = node_factory.get_node(options={'plugin': os.path.join(os.getcwd(), 'tests/plugins/utf8.py'),

'log-level': 'io'})

# This works because Python unmangles.

res = l1.rpc.call('utf8', ['ナンセンス 1杯'])

assert '\\u' not in res['utf8']

assert res['utf8'] == 'ナンセンス 1杯'

# Now, try native.

out = subprocess.check_output(['cli/lightning-cli',

'--network={}'.format(TEST_NETWORK),

'--lightning-dir={}'

.format(l1.daemon.lightning_dir),

'utf8', 'ナンセンス 1杯']).decode('utf-8')

assert '\\u' not in out

assert out == '{\n "utf8": "ナンセンス 1杯"\n}\n'

def test_invoice_payment_hook(node_factory):

""" l1 uses the reject-payment plugin to reject invoices with odd preimages.

"""

opts = [{}, {'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject_some_invoices.py')}]

l1, l2 = node_factory.line_graph(2, opts=opts)

# This one works

inv1 = l2.rpc.invoice(1230, 'label', 'description', preimage='1' * 64)

l1.rpc.pay(inv1['bolt11'])

l2.daemon.wait_for_log('label=label')

l2.daemon.wait_for_log('msat=')

l2.daemon.wait_for_log('preimage=' + '1' * 64)

# This one will be rejected.

inv2 = l2.rpc.invoice(1230, 'label2', 'description', preimage='0' * 64)

with pytest.raises(RpcError):

l1.rpc.pay(inv2['bolt11'])

pstatus = l1.rpc.call('paystatus', [inv2['bolt11']])['pay'][0]

assert pstatus['attempts'][-1]['failure']['data']['failcodename'] == 'WIRE_TEMPORARY_NODE_FAILURE'

l2.daemon.wait_for_log('label=label2')

l2.daemon.wait_for_log('msat=')

l2.daemon.wait_for_log('preimage=' + '0' * 64)

def test_invoice_payment_hook_hold(node_factory):

""" l1 uses the hold_invoice plugin to delay invoice payment.

"""

opts = [{}, {'plugin': os.path.join(os.getcwd(), 'tests/plugins/hold_invoice.py'), 'holdtime': TIMEOUT / 2}]

l1, l2 = node_factory.line_graph(2, opts=opts)

inv1 = l2.rpc.invoice(1230, 'label', 'description', preimage='1' * 64)

l1.rpc.pay(inv1['bolt11'])

@pytest.mark.openchannel('v1')

@pytest.mark.openchannel('v2')

def test_openchannel_hook(node_factory, bitcoind):

""" l2 uses the reject_odd_funding_amounts plugin to reject some openings.

"""

opts = [{}, {'plugin': os.path.join(os.getcwd(), 'tests/plugins/reject_odd_funding_amounts.py')}]

l1, l2 = node_factory.line_graph(2, fundchannel=False, opts=opts)

l1.fundwallet(10**6)

# Even amount: works.

l1.rpc.fundchannel(l2.info['id'], 100000)

# Make sure plugin got all the vars we expect

expected = {

'channel_flags': '1',

'dust_limit_msat': 546000,

'htlc_minimum_msat': 0,

'id': l1.info['id'],

'max_accepted_htlcs': '483',

'max_htlc_value_in_flight_msat': 18446744073709551615,

'to_self_delay': '5',

}

if 'anchors/even' in only_one(l1.rpc.listpeerchannels()['channels'])['channel_type']['names']:

feerate = 3750

expected['channel_type'] = r"{'bits': \[12, 22\], 'names': \['static_remotekey/even', 'anchors/even'\]}"

else:

feerate = 7500

expected['channel_type'] = r"{'bits': \[12\], 'names': \['static_remotekey/even'\]}"

if l2.config('experimental-dual-fund'):

# openchannel2 var checks

expected.update({

'channel_id': '.*',

'channel_max_msat': 2100000000000000000,

'commitment_feerate_per_kw': feerate,

'funding_feerate_per_kw': '7500',

'feerate_our_max': '150000',

'feerate_our_min': '1875',

'locktime': '.*',

'require_confirmed_inputs': False,

'their_funding_msat': 100000000,

})

else:

expected.update({

'channel_reserve_msat': 1000000,

'feerate_per_kw': feerate,

'funding_msat': 100000000,

'push_msat': 0,

})

l2.daemon.wait_for_log('reject_odd_funding_amounts.py: {} VARS'.format(len(expected)))

for k, v in expected.items():

assert l2.daemon.is_in_log('reject_odd_funding_amounts.py: {}={}'.format(k, v))

# Close it.

txid = only_one(l1.rpc.close(l2.info['id'])['txids'])

bitcoind.generate_block(1, txid)

wait_for(lambda: [c['state'] for c in l1.rpc.listpeerchannels(l2.info['id'])['channels']] == ['ONCHAIN'])

# Odd amount: fails

l1.connect(l2)

with pytest.raises(RpcError, match=r"I don't like odd amounts"):

l1.rpc.fundchannel(l2.info['id'], 100001)

@pytest.mark.openchannel('v1')

@pytest.mark.openchannel('v2')

def test_openchannel_hook_error_handling(node_factory, bitcoind):

""" l2 uses a plugin that should fatal() crash the node.

This is because the plugin rejects a channel while

also setting a close_to address which isn't allowed.

"""

opts = {'plugin': os.path.join(os.getcwd(), 'tests/plugins/openchannel_hook_accepter.py')}

# openchannel_reject_but_set_close_to.py')}

l1 = node_factory.get_node()

l2 = node_factory.get_node(options=opts,

expect_fail=True,

broken_log='lightningd: ',

may_fail=True)

l1.connect(l2)

l1.fundwallet(10**6)

# next fundchannel should fail fatal() for l2

with pytest.raises(RpcError, match=r'Owning subdaemon (openingd|dualopend) died'):

l1.rpc.fundchannel(l2.info['id'], 100004)

assert l2.daemon.is_in_log("BROKEN.*Plugin rejected openchannel[2]? but also set close_to")

@pytest.mark.openchannel('v1')

@pytest.mark.openchannel('v2')

def test_openchannel_hook_chaining(node_factory, bitcoind):

""" l2 uses a set of plugin that all use the openchannel_hook.

We test that chaining works by using multiple plugins in a way

that we check for the first plugin that rejects prevents from evaluating

further plugin responses down the chain.

"""

opts = [{}, {'plugin': [

os.path.join(os.path.dirname(__file__), '..', 'tests/plugins/openchannel_hook_accept.py'),

os.path.join(os.path.dirname(__file__), '..', 'tests/plugins/openchannel_hook_accepter.py'),

os.path.join(os.path.dirname(__file__), '..', 'tests/plugins/openchannel_hook_reject.py')

]}]

l1, l2 = node_factory.line_graph(2, fundchannel=False, opts=opts)

l1.fundwallet(10**6)

hook_msg = "openchannel2? hook rejects and says '"

# 100005sat fundchannel should fail fatal() for l2

# because hook_accepter.py rejects on that amount 'for a reason'

with pytest.raises(RpcError, match=r'reject for a reason'):

l1.rpc.fundchannel(l2.info['id'], 100005)

assert l2.daemon.wait_for_log(hook_msg + "reject for a reason")

# first plugin in the chain was called

assert l2.daemon.is_in_log("accept on principle")

# the third plugin must now not be called anymore

assert not l2.daemon.is_in_log("reject on principle")

assert only_one(l1.rpc.listpeers()['peers'])['connected']

# 100000sat is good for hook_accepter, so it should fail 'on principle'

# at third hook openchannel_reject.py

with pytest.raises(RpcError, match=r'reject on principle'):

l1.rpc.fundchannel(l2.info['id'], 100000)

assert l2.daemon.wait_for_log(hook_msg + "reject on principle")

@pytest.mark.openchannel('v1')

@pytest.mark.openchannel('v2')

def test_channel_state_changed_bilateral(node_factory, bitcoind):

""" We open and close a channel and check notifications both sides.

The misc_notifications.py plugin logs `channel_state_changed` events.

"""

opts = {"plugin": os.path.join(os.getcwd(), "tests/plugins/misc_notifications.py")}

l1, l2 = node_factory.line_graph(2, opts=opts)

l1_id = l1.rpc.getinfo()["id"]

l2_id = l2.rpc.getinfo()["id"]

cid = l1.get_channel_id(l2)

scid = l1.get_channel_scid(l2)

# a helper that gives us the next channel_state_changed log entry

def wait_for_event(node):

msg = node.daemon.wait_for_log("plugin-misc_notifications.py: channel_state_changed.*new_state.*")

event = ast.literal_eval(re.findall(".*({.*}).*", msg)[0])

return event

# check channel 'opener' and 'closer' within this testcase ...

assert(l1.rpc.listpeerchannels()['channels'][0]['opener'] == 'local')

assert(l2.rpc.listpeerchannels()['channels'][0]['opener'] == 'remote')

# the 'closer' should be missing initially

assert 'closer' not in l1.rpc.listpeerchannels()['channels'][0]

assert 'closer' not in l2.rpc.listpeerchannels()['channels'][0]

if l1.config('experimental-dual-fund'):

# Dual funded channels go through three state transitions.

event1a, event1b, event1c = wait_for_event(l1), wait_for_event(l1), wait_for_event(l1)

event2a, event2b, event2c = wait_for_event(l2), wait_for_event(l2), wait_for_event(l2)

for ev in [event1a, event1b]:

assert(ev['peer_id'] == l2_id) # we only test these IDs the first time

assert(ev['channel_id'] == cid)

assert('short_channel_id' not in ev) # Missing until locked in

assert(ev['cause'] == "remote")

for ev in [event2a, event2b]:

assert(ev['peer_id'] == l1_id) # we only test these IDs the first time

assert(ev['channel_id'] == cid)

assert('short_channel_id' not in ev) # Missing until locked in

assert(ev['cause'] == "remote")

for ev in [event1a, event2a]:

assert(ev['old_state'] == "DUALOPEND_OPEN_INIT")

assert(ev['new_state'] == "DUALOPEND_OPEN_COMMIT_READY")

assert(ev['message'] == "Ready to send our commitment sigs")

for ev in [event1b, event2b]:

assert(ev['old_state'] == "DUALOPEND_OPEN_COMMIT_READY")

assert(ev['new_state'] == "DUALOPEND_OPEN_COMMITTED")

assert(ev['message'] == "Commitment transaction committed")

for ev in [event1c, event2c]:

assert(ev['old_state'] == "DUALOPEND_OPEN_COMMITTED")

assert(ev['new_state'] == "DUALOPEND_AWAITING_LOCKIN")

assert(ev['message'] == "Sigs exchanged, waiting for lock-in")

else:

event1 = wait_for_event(l1)

event2 = wait_for_event(l2)

assert(event1['peer_id'] == l2_id) # we only test these IDs the first time

assert(event1['channel_id'] == cid)

assert('short_channel_id' not in event1) # Not present until locked in

assert(event1['cause'] == "user")

assert(event2['peer_id'] == l1_id) # we only test these IDs the first time

assert(event2['channel_id'] == cid)

assert('short_channel_id' not in event2) # Not present until locked in

assert(event2['cause'] == "remote")

for ev in [event1, event2]:

'old_state' not in ev

assert(ev['new_state'] == "CHANNELD_AWAITING_LOCKIN")

assert(ev['message'] == "new channel opened")

event1 = wait_for_event(l1)

event2 = wait_for_event(l2)

assert(event1['short_channel_id'] == scid)

if l1.config('experimental-dual-fund'):

assert(event1['old_state'] == "DUALOPEND_AWAITING_LOCKIN")

else:

assert(event1['old_state'] == "CHANNELD_AWAITING_LOCKIN")

assert(event1['new_state'] == "CHANNELD_NORMAL")

assert(event1['cause'] == "user")

assert(event1['message'] == "Lockin complete")

assert(event2['short_channel_id'] == scid)

if l1.config('experimental-dual-fund'):

assert(event2['old_state'] == "DUALOPEND_AWAITING_LOCKIN")

else:

assert(event2['old_state'] == "CHANNELD_AWAITING_LOCKIN")

assert(event2['new_state'] == "CHANNELD_NORMAL")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Lockin complete")

# also test the correctness of timestamps once

assert(datetime.strptime(event1['timestamp'], '%Y-%m-%dT%H:%M:%S.%fZ'))

assert(datetime.strptime(event2['timestamp'], '%Y-%m-%dT%H:%M:%S.%fZ'))

# close channel and look for stateful events

l1.rpc.close(scid)

event1 = wait_for_event(l1)

assert(event1['old_state'] == "CHANNELD_NORMAL")

assert(event1['new_state'] == "CHANNELD_SHUTTING_DOWN")

assert(event1['cause'] == "user")

assert(event1['message'] == "User or plugin invoked close command")

event2 = wait_for_event(l2)

assert(event2['old_state'] == "CHANNELD_NORMAL")

assert(event2['new_state'] == "CHANNELD_SHUTTING_DOWN")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Peer closes channel")

# 'closer' should now be set accordingly ...

assert(l1.rpc.listpeerchannels()['channels'][0]['closer'] == 'local')

assert(l2.rpc.listpeerchannels()['channels'][0]['closer'] == 'remote')

event1 = wait_for_event(l1)

assert(event1['old_state'] == "CHANNELD_SHUTTING_DOWN")

assert(event1['new_state'] == "CLOSINGD_SIGEXCHANGE")

assert(event1['cause'] == "user")

assert(event1['message'] == "Start closingd")

event2 = wait_for_event(l2)

assert(event2['old_state'] == "CHANNELD_SHUTTING_DOWN")

assert(event2['new_state'] == "CLOSINGD_SIGEXCHANGE")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Start closingd")

event1 = wait_for_event(l1)

assert(event1['old_state'] == "CLOSINGD_SIGEXCHANGE")

assert(event1['new_state'] == "CLOSINGD_COMPLETE")

assert(event1['cause'] == "user")

assert(event1['message'] == "Closing complete")

event2 = wait_for_event(l2)

assert(event2['old_state'] == "CLOSINGD_SIGEXCHANGE")

assert(event2['new_state'] == "CLOSINGD_COMPLETE")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Closing complete")

bitcoind.generate_block(100, wait_for_mempool=1) # so it gets settled

event1 = wait_for_event(l1)

assert(event1['old_state'] == "CLOSINGD_COMPLETE")

assert(event1['new_state'] == "FUNDING_SPEND_SEEN")

assert(event1['cause'] == "user")

assert(event1['message'] == "Onchain funding spend")

event2 = wait_for_event(l2)

assert(event2['old_state'] == "CLOSINGD_COMPLETE")

assert(event2['new_state'] == "FUNDING_SPEND_SEEN")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Onchain funding spend")

event1 = wait_for_event(l1)

assert(event1['old_state'] == "FUNDING_SPEND_SEEN")

assert(event1['new_state'] == "ONCHAIN")

assert(event1['cause'] == "user")

assert(event1['message'] == "Onchain init reply")

event2 = wait_for_event(l2)

assert(event2['old_state'] == "FUNDING_SPEND_SEEN")

assert(event2['new_state'] == "ONCHAIN")

assert(event2['cause'] == "remote")

assert(event2['message'] == "Onchain init reply")

@pytest.mark.openchannel('v1')

@pytest.mark.openchannel('v2')

def test_channel_state_changed_unilateral(node_factory, bitcoind):

""" We open, disconnect, force-close a channel and check for notifications.

The misc_notifications.py plugin logs `channel_state_changed` events.

"""

opts = {"plugin": os.path.join(os.getcwd(), "tests/plugins/misc_notifications.py"),

"allow_warning": True,

'may_reconnect': True}

l1, l2 = node_factory.line_graph(2, opts=opts)

l1_id = l1.rpc.getinfo()["id"]

cid = l1.get_channel_id(l2)

scid = l1.get_channel_scid(l2)

# a helper that gives us the next channel_state_changed log entry

def wait_for_event(node):

msg = node.daemon.wait_for_log("plugin-misc_notifications.py: channel_state_changed.*new_state.*")

event = ast.literal_eval(re.findall(".*({.*}).*", msg)[0])

return event

event2 = wait_for_event(l2)

assert(event2['peer_id'] == l1_id)

assert(event2['channel_id'] == cid)

assert('short_channel_id' not in event2)

assert(event2['cause'] == "remote")

if l2.config('experimental-dual-fund'):

assert(event2['old_state'] == "DUALOPEND_OPEN_INIT")

assert(event2['new_state'] == "DUALOPEND_OPEN_COMMIT_READY")

assert(event2['message'] == "Ready to send our commitment sigs")

event2 = wait_for_event(l2)