Cbf add broadcast

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex

[randomlogin]

This PR lives ontop of #29

[febyeji]

I spotted this from codex PR review , and it may be worth checking:

This part assumes that package is already in order, but LDK may give us child-first, parent-later package. LDK's BroadcasterInterface::broadcast_transactions explicitly says implementations must not assume any topological order for multi-transaction packages.

[randomlogin]

Yes, that could happen. In that case from_vec fails and we broadcast txs one by one, and in case they are dependent, the receiving node may receive child first and reject it.

But it is what all other chain sources do:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
self.electrum_runtime_status.read().expect("lock").client().as_ref()
{
Arc::clone(client)
} else {
debug_assert!(false, "We should have started the chain source before broadcasting");
return;
};
for tx in package {
electrum_client.broadcast(tx).await;
}
}
}

bitcoind:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
// features, we should eventually switch to use `submitpackage` via the
// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
// transactions.
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
self.api_client.broadcast_transaction(tx),
);
match timeout_fut.await {
Ok(res) => match res {
Ok(id) => {
debug_assert_eq!(id, txid);
log_trace!(self.logger, "Successfully broadcast transaction {}", txid);
},
Err(e) => {
log_error!(self.logger, "Failed to broadcast transaction {}: {}", txid, e);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
},
Err(e) => {
log_error!(
self.logger,
"Failed to broadcast transaction due to timeout {}: {}",
txid,
e
);
log_trace!(
self.logger,
"Failed broadcast transaction bytes: {}",
log_bytes!(tx.encode())
);
},
}
}
}

and esplora:

	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
for tx in &package {
let txid = tx.compute_txid();
let timeout_fut = tokio::time::timeout(
Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
self.esplora_client.broadcast(tx),
);
...

So I guess we're at least not worse than other chain sources and perhaps currently package comes ordered.

[randomlogin]

Maybe we can open a PR to ldk-node to add helper which is called inside continuously_process_broadcast_queue which topologically orders the package before submitting it to the broadcaster?

[febyeji]

I agree that we can add a PR to ldk-node about this. Let's keep this way for now!

[febyeji]

Applied this contribution to cbf-chain-source-cleanup as commit 9d36b17 (cbf: implement package broadcasting), preserving Alexander Shevtsov as the commit author. Closing this PR instead of merging per permission to incorporate the work with attribution.

AI-assisted-by: OpenAI Codex