You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
97 lines
2.6 KiB
97 lines
2.6 KiB
#include "funding.h"
|
|
#include <assert.h>
|
|
|
|
bool funding_delta(const OpenChannel *a,
|
|
const OpenChannel *b,
|
|
const OpenAnchor *anchor,
|
|
uint64_t fee,
|
|
uint64_t *channel_delta,
|
|
int64_t delta_a_to_b,
|
|
uint64_t *a_amount,
|
|
uint64_t *b_amount)
|
|
{
|
|
uint64_t *funder_amount, *non_funder_amount, new_delta;
|
|
int64_t delta_to_funder;
|
|
uint64_t funder_fee, non_funder_fee;
|
|
|
|
assert(*channel_delta <= anchor->amount);
|
|
|
|
if (a->anch == OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR) {
|
|
if (b->anch != OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR)
|
|
return false;
|
|
funder_amount = a_amount;
|
|
non_funder_amount = b_amount;
|
|
delta_to_funder = delta_a_to_b;
|
|
} else {
|
|
if (a->anch != OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR)
|
|
return false;
|
|
if (b->anch != OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR)
|
|
return false;
|
|
funder_amount = b_amount;
|
|
non_funder_amount = a_amount;
|
|
delta_to_funder = -delta_a_to_b;
|
|
}
|
|
|
|
/* Trying to spend more than non-funder has? */
|
|
if (delta_to_funder > 0) {
|
|
if (delta_to_funder > *channel_delta)
|
|
return false;
|
|
/* Trying to spend more than funder has? */
|
|
} else if (-delta_to_funder > anchor->amount - *channel_delta)
|
|
return false;
|
|
|
|
new_delta = *channel_delta - delta_to_funder;
|
|
*funder_amount = anchor->amount - new_delta;
|
|
*non_funder_amount = new_delta;
|
|
|
|
/* We try to split fee. */
|
|
funder_fee = fee / 2;
|
|
/* Funder gets any 1 satoshi rounding benefit! */
|
|
non_funder_fee = fee - funder_fee;
|
|
|
|
if (*non_funder_amount < non_funder_fee) {
|
|
/*
|
|
* This happens initially, as funder has all the money.
|
|
* That's OK, but don't let non-funder withdraw if they can't
|
|
* cover fee.
|
|
*/
|
|
if (delta_to_funder > 0)
|
|
return false;
|
|
|
|
/* Pay everything they can, funder pays rest. */
|
|
non_funder_fee = *non_funder_amount;
|
|
funder_fee = fee - non_funder_fee;
|
|
}
|
|
|
|
/* Funder must always ensure they can pay their share. */
|
|
if (*funder_amount < funder_fee)
|
|
return false;
|
|
|
|
*funder_amount -= funder_fee;
|
|
*non_funder_amount -= non_funder_fee;
|
|
|
|
/* Now we know we're succeeding, update caller's channel_delta */
|
|
*channel_delta = new_delta;
|
|
return true;
|
|
}
|
|
|
|
bool initial_funding(const OpenChannel *a,
|
|
const OpenChannel *b,
|
|
const OpenAnchor *anchor,
|
|
uint64_t fee,
|
|
uint64_t *a_amount,
|
|
uint64_t *b_amount)
|
|
{
|
|
uint64_t channel_delta = 0;
|
|
|
|
return funding_delta(a, b, anchor, fee, &channel_delta, 0,
|
|
a_amount, b_amount);
|
|
}
|
|
|
|
/* We take the minimum. If one side offers too little, it should be rejected */
|
|
uint64_t commit_fee(const OpenChannel *a, const OpenChannel *b)
|
|
{
|
|
if (a->commitment_fee < b->commitment_fee)
|
|
return a->commitment_fee;
|
|
return b->commitment_fee;
|
|
}
|
|
|