WIP Commit

Work is still in progress!

Author: ddustin

channeld/channeld.c

@@ -955,6 +955,10 @@ static struct bitcoin_signature *calc_commitsigs(const tal_t *ctx,
 	const u8 *msg;
 	struct bitcoin_signature *htlc_sigs;
 
+	status_debug("calc_commitsigs(%p, %p, %p, %p, %p, %d, %p, %p)",
+		     ctx, peer, txs, funding_wscript, htlc_map,
+		     (int)commit_index, remote_per_commit, commit_sig);
+
 	htlcs = collect_htlcs(tmpctx, htlc_map);
 	msg = towire_hsmd_sign_remote_commitment_tx(NULL, txs[0],
 						    &remote_funding_pubkey,
@@ -3308,7 +3312,7 @@ static struct amount_sat calc_balance(struct peer *peer)
 }
 
 /* Returns the total channel funding output amount if all checks pass.
- * Otherwise, exits via peer_failed_warn. DTODO: Change to `tx_abort`. */
+ * Otherwise, exits via peer_failed_warn. */
 static struct amount_sat check_balances(struct peer *peer,
 					enum tx_role our_role,
 					const struct wally_psbt *psbt,
@@ -3349,6 +3353,32 @@ static struct amount_sat check_balances(struct peer *peer,
 					 "Unable to add HTLC balance");
 	}
 
+	status_debug("in[TX_INITIATOR] %s; in[TX_ACCEPTER] %s",
+		     fmt_amount_m_as_sat(tmpctx, in[TX_INITIATOR]),
+		     fmt_amount_m_as_sat(tmpctx, in[TX_ACCEPTER]));
+
+	/* Here in[*] only contains the amounts from this channel.
+	 * This is a great opportunity to check their splice out amount does
+	 * not exceed their channel funds as this is never allowed even if
+	 * additional funds are otherwise contributed. */
+	if (!amount_msat_can_add_sat_s64(in[TX_INITIATOR],
+					 peer->splicing->opener_relative)) {
+		splice_abort(peer, "Intiator is attempting to splice out"
+			     " %"PRId64"sat funds out of channel while only "
+			     "having %s funds attributable to them.",
+			     peer->splicing->opener_relative,
+			     fmt_amount_m_as_sat(tmpctx, in[TX_INITIATOR]));
+	}
+	if (!amount_msat_can_add_sat_s64(in[TX_ACCEPTER],
+					 peer->splicing->accepter_relative)) {
+		splice_abort(peer, "Accepter is attempting to splice out"
+			     " %"PRId64"sat funds out of channel while only "
+			     "having %s funds attributable to them.",
+			     peer->splicing->accepter_relative,
+			     fmt_amount_m_as_sat(tmpctx, in[TX_ACCEPTER]));
+	}
+
+	/* Now add values from the other outputs */
 	for (size_t i = 0; i < psbt->num_inputs; i++)
 		if (i != chan_input_index)
 			add_amount_to_side(peer, in,
@@ -3402,6 +3432,11 @@ static struct amount_sat check_balances(struct peer *peer,
 			     " %"PRIu64,
 			     fmt_amount_msat(tmpctx, funding_amount),
 			     peer->splicing->opener_relative);
+
+	status_debug("out[TX_INITIATOR] %s + %"PRId64,
+		     fmt_amount_m_as_sat(tmpctx, out[TX_INITIATOR]),
+		     peer->splicing->opener_relative);
+
 	if (!amount_msat_add_sat_s64(&out[TX_INITIATOR], out[TX_INITIATOR],
 				     peer->splicing->opener_relative))
 		peer_failed_warn(peer->pps, &peer->channel_id,
@@ -3416,6 +3451,10 @@ static struct amount_sat check_balances(struct peer *peer,
 		peer_failed_warn(peer->pps, &peer->channel_id,
 				 "Unable to add accepter funding to out amnt.");
 
+	status_debug("is in[TX_INITIATOR] %s less than out[TX_INITIATOR] %s?",
+		     fmt_amount_m_as_sat(tmpctx, in[TX_INITIATOR]),
+		     fmt_amount_m_as_sat(tmpctx, out[TX_INITIATOR]));
+
 	if (amount_msat_less(in[TX_INITIATOR], out[TX_INITIATOR])) {
 		msg = towire_channeld_splice_funding_error(NULL,
 							   in[TX_INITIATOR],

channeld/full_channel.c

@@ -324,8 +324,10 @@ struct bitcoin_tx **channel_txs(const tal_t *ctx,
 			   &channel->basepoints[side],
 			   &channel->basepoints[!side],
 			   channel_has(channel, OPT_STATIC_REMOTEKEY),
-			   &keyset))
+			   &keyset)) {
+		status_broken("channel_txs fails to derive keyset");
 		return NULL;
+	}
 
 	/* Figure out what @side will already be committed to. */
 	gather_htlcs(ctx, channel, side, &committed, NULL, NULL);
@@ -339,16 +341,54 @@ struct bitcoin_tx **channel_txs(const tal_t *ctx,
 	side_pay = channel->view[side].owed[side];
 	other_side_pay = channel->view[side].owed[!side];
 
+	status_debug("channel->view[REMOTE].owed[REMOTE] %s;"
+		     " channel->view[REMOTE].owed[LOCAL] %s;"
+		     " channel->view[LOCAL].owed[REMOTE] %s;"
+		     " channel->view[LOCAL].owed[LOCAL] %s;",
+		     fmt_amount_m_as_sat(tmpctx,
+					 channel->view[REMOTE].owed[REMOTE]),
+		     fmt_amount_m_as_sat(tmpctx,
+					 channel->view[REMOTE].owed[LOCAL]),
+		     fmt_amount_m_as_sat(tmpctx,
+					 channel->view[LOCAL].owed[REMOTE]),
+		     fmt_amount_m_as_sat(tmpctx,
+					 channel->view[LOCAL].owed[LOCAL]));
+
 	if (side == LOCAL) {
-		if (!amount_msat_add_sat_s64(&side_pay, side_pay, splice_amnt))
+		if (!amount_msat_add_sat_s64(&side_pay, side_pay, splice_amnt)) {
+			status_broken("channel_txs fails to"
+				      " amount_msat_add_sat_s64 %s + %"PRId64
+				      " LOCAL (side_pay + splice_amnt)",
+				      fmt_amount_m_as_sat(tmpctx, side_pay),
+				      splice_amnt);
 			return NULL;
-		if (!amount_msat_add_sat_s64(&other_side_pay, other_side_pay, remote_splice_amnt))
+		}
+		if (!amount_msat_add_sat_s64(&other_side_pay, other_side_pay, remote_splice_amnt)) {
+			status_broken("channel_txs fails to"
+				      " amount_msat_add_sat_s64 %s + %"PRId64
+				      " LOCAL (other_side_pay + remote_splice_amnt)",
+				      fmt_amount_m_as_sat(tmpctx, other_side_pay),
+				      remote_splice_amnt);
 			return NULL;
+		}
 	} else if (side == REMOTE) {
-		if (!amount_msat_add_sat_s64(&side_pay, side_pay, remote_splice_amnt))
+// channel_txs fails to amount_msat_add_sat_s64 0sat + -100000 REMOTE (side_pay + remote_splice_amnt)
+		if (!amount_msat_add_sat_s64(&side_pay, side_pay, remote_splice_amnt)) {
+			status_broken("channel_txs fails to"
+				      " amount_msat_add_sat_s64 %s + %"PRId64
+				      " REMOTE (side_pay + remote_splice_amnt)",
+				      fmt_amount_m_as_sat(tmpctx, side_pay),
+				      remote_splice_amnt);
 			return NULL;
-		if (!amount_msat_add_sat_s64(&other_side_pay, other_side_pay, splice_amnt))
+		}
+		if (!amount_msat_add_sat_s64(&other_side_pay, other_side_pay, splice_amnt)){
+			status_broken("channel_txs fails to"
+				      " amount_msat_add_sat_s64 %s + %"PRId64
+				      " REMOTE (other_side_pay + splice_amnt)",
+				      fmt_amount_m_as_sat(tmpctx, other_side_pay),
+				      splice_amnt);
 			return NULL;
+		}
 	}
 
 	txs = tal_arr(ctx, struct bitcoin_tx *, 1);

common/amount.c

@@ -400,6 +400,13 @@ WARN_UNUSED_RESULT bool amount_sat_add_sat_s64(struct amount_sat *val,
 		return amount_sat_add(val, a, amount_sat(b));
 }
 
+bool amount_msat_can_add_sat_s64(struct amount_msat a, s64 b)
+{
+	struct amount_msat val;
+	/* This fails if the result goes below 0 */
+	return amount_msat_add_sat_s64(&val, a, b);
+}
+
 bool amount_sat_eq(struct amount_sat a, struct amount_sat b)
 {
 	return a.satoshis == b.satoshis;

common/amount.h

@@ -100,6 +100,9 @@ WARN_UNUSED_RESULT bool amount_sat_add_sat_s64(struct amount_sat *val,
 					       struct amount_sat a,
 					       s64 b);
 
+WARN_UNUSED_RESULT bool amount_msat_can_add_sat_s64(struct amount_msat a,
+						    s64 b);
+
 /* a += b */
 WARN_UNUSED_RESULT bool amount_msat_accumulate(struct amount_msat *a,
 					       struct amount_msat b);

common/splice_script.c

@@ -282,6 +282,19 @@ static struct splice_script_error *new_error(const tal_t *ctx,
 	return new_error_offset(ctx, type, token, phase, 0);
 }
 
+static struct splice_script_error *new_error_msg(const tal_t *ctx,
+						 enum splice_script_error_type type,
+						 struct token *token,
+						 const char *phase,
+						 char *msg)
+{
+	struct splice_script_error *error = new_error(ctx, type, token, phase);
+
+	tal_append_fmt(&error->message, "%s", msg);
+
+	return error;
+}
+
 static char *context_snippet(const tal_t *ctx,
 			     const char *script,
 			     struct splice_script_error *error)
@@ -2345,10 +2358,15 @@ static struct splice_script_error *calculate_amounts(const tal_t *ctx,
 	/* Do we know precisely how much we're getting? */
 	if (!right_wilds && !right_used_ppm) {
 		/* Then we can give sat amount errors */
-		if (amount_sat_greater(left_total, right_total))
-			return new_error(ctx, INSUFFICENT_FUNDS,
-					 left_wildcard_token ?: input[0],
-					 "calculate_amounts");
+		if (amount_sat_greater(left_total, right_total)) {
+			return new_error_msg(ctx, INSUFFICENT_FUNDS,
+					     left_wildcard_token ?: input[0],
+					     "calculate_amounts",
+					     tal_fmt(tmpctx, "required: %s,"
+						     " provided: %s",
+						     fmt_amount_sat(tmpctx, left_total),
+						     fmt_amount_sat(tmpctx, right_total)));
+		}
 		if (left_used_ppm && amount_sat_eq(left_total, right_total))
 			return new_error(ctx, PERCENT_IS_ZERO,
 					 left_percent_token ?: input[0],

plugins/spender/splice.c

@@ -394,8 +394,6 @@ static struct command_result *onchain_wallet_fund(struct command *cmd,
 	if (addinginputs) {
 		command = "addpsbtinput";
 		splice_cmd->wallet_inputs_to_signed++;
-		/* DTODO track which specific inputs are added and only sign
-		 * those */
 	}
 
 	req = jsonrpc_request_start(cmd, command,

tests/test_splice.py

@@ -227,3 +227,152 @@ def test_script_two_chan_splice_in(node_factory, bitcoind):
 
     inv = l3.rpc.invoice(10**2, '2', 'no_2')
     l2.rpc.pay(inv['bolt11'])
+
+
+@pytest.mark.openchannel('v1')
+@pytest.mark.openchannel('v2')
+@unittest.skipIf(TEST_NETWORK != 'regtest', 'elementsd doesnt yet support PSBT features we need')
+def test_script_two_chan_splice_out(node_factory, bitcoind):
+    l1, l2, l3 = node_factory.line_graph(3, fundamount=1000000, wait_for_announce=True, opts={'experimental-splicing': None})
+
+    # We need to get funds into l1 -> l2 channel so we can splice it out
+    inv = l2.rpc.invoice(100000000, '1', 'no_1')
+    l1.rpc.pay(inv['bolt11'])
+
+    chan_id1 = l2.get_channel_id(l1)
+    chan_id2 = l2.get_channel_id(l3)
+
+    # l2 will splice funds ouit of the channels with l1 and l3 at the same time
+    result = l2.rpc.splice(f"{chan_id1} -> 100000; {chan_id2} -> 100000")
+
+    l3.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+    l2.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+    l1.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+
+    wait_for(lambda: len(list(bitcoind.rpc.getrawmempool(True).keys())) == 1)
+    assert result['txid'] in list(bitcoind.rpc.getrawmempool(True).keys())
+
+    bitcoind.generate_block(6, wait_for_mempool=1)
+
+    l3.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+    l2.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+    l1.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+
+    inv = l2.rpc.invoice(10**2, '2', 'no_2')
+    l1.rpc.pay(inv['bolt11'])
+
+    inv = l3.rpc.invoice(10**2, '3', 'no_3')
+    l2.rpc.pay(inv['bolt11'])
+
+
+@pytest.mark.openchannel('v1')
+@pytest.mark.openchannel('v2')
+@unittest.skipIf(TEST_NETWORK != 'regtest', 'elementsd doesnt yet support PSBT features we need')
+def test_script_two_chan_splice_inout(node_factory, bitcoind):
+    l1, l2, l3 = node_factory.line_graph(3, fundamount=1000000, wait_for_announce=True, opts={'experimental-splicing': None})
+
+    chan_id1 = l2.get_channel_id(l1)
+    chan_id2 = l2.get_channel_id(l3)
+
+    # move sats from chan 2 into chan 1
+    result = l2.rpc.splice(f"wallet -> 10000; 100000 -> {chan_id1}; {chan_id2} -> 100000")
+
+    l3.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+    l2.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+    l1.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+
+    wait_for(lambda: len(list(bitcoind.rpc.getrawmempool(True).keys())) == 1)
+    assert result['txid'] in list(bitcoind.rpc.getrawmempool(True).keys())
+
+    bitcoind.generate_block(6, wait_for_mempool=1)
+
+    l3.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+    l2.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+    l1.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+
+    inv = l2.rpc.invoice(10**2, '2', 'no_2')
+    l1.rpc.pay(inv['bolt11'])
+
+    inv = l3.rpc.invoice(10**2, '3', 'no_3')
+    l2.rpc.pay(inv['bolt11'])
+
+
+# Makes channels going from node 1 -> 2, 2 -> 3, etc up to 'qty' number channels.
+# If balanced is True, than each channel will be balanced -- otherwise the lower
+# index channel will have funds in the channel to the higher indexed one.
+# The second node is a *special case* -- it will get a channel to every other node.
+# Returns an array of all nodes, and an array of all the *second node's* channels
+def make_chans(node_factory, qty=2, fundamount=1000000, balanced=True):
+    nodes = node_factory.line_graph(qty+1, fundamount=fundamount, opts={'experimental-splicing': None})
+    chanids = []
+
+    if qty > 2:
+        for i in range(len(nodes) - 1, 2, -1):
+            chanid, _ = nodes[2].fundchannel(nodes[i].info["id"], fundamount)
+            chanids.append(chanid)
+
+    assert(qty > 1);
+    chanids.insert(0, nodes[1],get_channel_id(nodes[0]))
+    chanids.insert(0, nodes[1],get_channel_id(nodes[0]))
+
+    for i in range(len(nodes) - 1):
+        if i == 1:
+            continue;
+
+            TODO: balane the cahnenls for node[1]!!!
+        chanids.append(nodes[i].get_channel_id(nodes[i + 1]))
+        if balanced:
+            inv = nodes[i + 1].rpc.invoice(int(1000 * fundamount / 2), str(i) + "bal", str(i) + "bal")
+            nodes[i].rpc.pay(inv['bolt11'])
+
+    return [nodes, chanids]
+
+
+def test_chans(nodes, txid, bitcoind, payment_check_style = 1, payamount=1000000):
+    for node in nodes:
+        node.daemon.wait_for_log(r'CHANNELD_NORMAL to CHANNELD_AWAITING_SPLICE')
+
+    wait_for(lambda: len(list(bitcoind.rpc.getrawmempool(True).keys())) == 1)
+    assert txid in list(bitcoind.rpc.getrawmempool(True).keys())
+
+    bitcoind.generate_block(6, wait_for_mempool=1)
+
+    for node in nodes:
+        node.daemon.wait_for_log(r'CHANNELD_AWAITING_SPLICE to CHANNELD_NORMAL')
+
+    if payment_check_style == 1:
+        for i in range(len(nodes) - 1):
+            inv = nodes[i + 1].rpc.invoice(payamount, str(i) + "test", str(i) + "test")
+            nodes[i].rpc.pay(inv['bolt11'])
+
+
+@pytest.mark.openchannel('v1')
+@pytest.mark.openchannel('v2')
+@unittest.skipIf(TEST_NETWORK != 'regtest', 'elementsd doesnt yet support PSBT features we need')
+def test_script_two_chan_splice_crazy(node_factory, bitcoind):
+    scripts = [
+        "wallet -> 10000; {} -> 100000; {} -> 100000",
+        "wallet -> 10000; 100000 -> {}; {} -> 100000",
+        "wallet -> 200000; 100000 -> {}; 100000 -> {}",
+        "{} -> 100000; {} -> 100000",
+        "{} -> 200000; 100000 -> {}", # '* -> wallet' is implied here
+        "{} -> 200000; 100000 -> {}; * -> wallet", # but we test it here explicitly
+        # "wallet -> 200000+fee; 100000 -> {}; 100000 -> {}", # Don't support wallet funding being used for fee
+        # "wallet -> *; 100000 -> {}; 100000 -> {}", # Don't support dynamic wallet funding amounts for now
+        # "100000 -> {}; {} -> 100000+fee", # Internal error; should not get here with non-channels with state NONE
+        # "100000-fee -> {}; {} -> 100000", # Internal error; should not get here with non-channels with state NONE
+    ]
+
+    for script in scripts:
+        nodes, chanids = make_chans(node_factory, script.count("{}"))
+        result = nodes[1].rpc.splice(script.format(*chanids))
+        test_chans(nodes, result['txid'], bitcoind)
+
+
+
+
+
+
+
+
+