Exemplo n.º 1
0
/* Send a preimage for the old commit tx.  The one we've just committed to is
 * in peer->us.commit. */
void queue_pkt_revocation(struct peer *peer)
{
	UpdateRevocation *u = tal(peer, UpdateRevocation);

	update_revocation__init(u);

	assert(peer->commit_tx_counter > 0);
	assert(peer->us.commit);
	assert(peer->us.commit->prev);
	assert(!peer->us.commit->prev->revocation_preimage);

	/* We have their signature on the current one, right? */
	assert(peer->us.commit->sig);

	peer->us.commit->prev->revocation_preimage
		= tal(peer->us.commit->prev, struct sha256);
	peer_get_revocation_preimage(peer, peer->commit_tx_counter-1,
				     peer->us.commit->prev->revocation_preimage);
	u->revocation_preimage
		= sha256_to_proto(u, peer->us.commit->prev->revocation_preimage);

	u->next_revocation_hash = sha256_to_proto(u,
						  &peer->us.next_revocation_hash);
	u->ack = peer_outgoing_ack(peer);

	queue_pkt(peer, PKT__PKT_UPDATE_REVOCATION, u);
}
Exemplo n.º 2
0
/* Send a preimage for the old commit tx.  The one we've just committed to is
 * in peer->local.commit. */
void queue_pkt_revocation(struct peer *peer)
{
	UpdateRevocation *u = tal(peer, UpdateRevocation);
	struct commit_info *ci;

	update_revocation__init(u);

	assert(peer->local.commit);
	ci = peer->local.commit->prev;
	assert(ci);
	assert(!ci->revocation_preimage);

	/* We have their signature on the current one, right? */
	assert(peer->local.commit->sig);

	ci->revocation_preimage = tal(ci, struct sha256);
	peer_get_revocation_preimage(peer, ci->commit_num,
				     ci->revocation_preimage);

	u->revocation_preimage = sha256_to_proto(u, ci->revocation_preimage);

	u->next_revocation_hash = sha256_to_proto(u,
						  &peer->local.next_revocation_hash);

	queue_pkt(peer, PKT__PKT_UPDATE_REVOCATION, u);

	/* BOLT #2:
	 *
	 * The node sending `update_revocation` MUST add the local unacked
	 * changes to the set of remote acked changes.
	 */
	/* Note: this means the unacked changes as of the commit we're
	 * revoking */
	add_acked_changes(&peer->remote.commit->acked_changes, ci->unacked_changes);
	apply_changeset(peer, &peer->remote, THEIRS,
			ci->unacked_changes, tal_count(ci->unacked_changes));

	if (tal_count(ci->unacked_changes))
		remote_changes_pending(peer);

	/* We should never look at this again. */
	ci->unacked_changes = tal_free(ci->unacked_changes);

	/* That revocation has committed us to changes in the current commitment.
	 * Any acked changes come from their commitment, so those are now committed
	 * by both of us.
	 */
	peer_both_committed_to(peer, ci->acked_changes, OURS);
}