Start publishing PaymentForwarded events.

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,

[G8XSU]

• Start publishing PaymentForwarded events.
  Required for ldk-server implementation or rather any forwarding node. Since a mobile node shouldn't be forwarding payments, these shouldn't get generated for mobile nodes.

[G8XSU]

404 Secured!

[G8XSU]

Pushed minor fix to fix CI.

[tnull]

Thanks!

This is somewhat preexisting, but will be more important if we introduce this event: going forward we need to consider steps to mitigate the potential DoS issue that might arise if users don't handle events fast enough and our event queue and forwarding/payment stores grow unboundedly.

Maybe we should extend the docs on Node in general and Node::next_event to stress more explicitly that users really need to handle events as fast as possible, especially if they would ever open announced channels? Also, we might need to consider starting to bound the event queue as dropping events is preferable to risk running OOM?

So I think we should take some (initial) mitigation steps as part of this PR or as a follow-up.

[G8XSU]

I don't think dropping events is a good idea, as users might miss that information. (discussed it offline in dev-sync, we need a way for ldk to somehow stop publishing events if event queue is beyond some large threshold.)

In Node::next_event we need to stress more explicitly that users really need to handle events as fast as possible.

I understand, will do it as separate PR.

[G8XSU]

Created #405 as separate PR.

[enigbe]

As a follow-up to @tnull's comment, I have just a small question about event handling for older-versioned events in the event queue of upgraded nodes.

[G8XSU]

Addressed all comments, kept prev_channel_id & next_channel_id as non-optional since there was never an ldk-node release with LDK < 0.0.0115. (and those were introduced in 0.0.107)

[tnull]

Basically LGTM (mod addressing/clarifying open comments).

Could you add some basic test coverage for this, e.g., by adding some

expect_event!(nodes[X],PaymentForwarded);

checks for the intermediate node in the multi_hop_sending test?

[tnull]

@G8XSU Let me know when you addressed the final round of comments/added some test coverage.

[G8XSU]

Addressed comments, Added tests and asserting over single payment path, waiting for CI and msrv check.

Do i need to send it over specific path and then assert?

[tnull]

LGTM, mod one comment and one nit.

Feel free to address them while squashing in the fixups to get this in a mergeable state.

[G8XSU]

Squashed with current fixups,