run: |
cd lightning
RUSTFLAGS="--cfg=require_route_graph_test" cargo test
- RUSTFLAGS="--cfg=require_route_graph_test" cargo test --features hashbrown
cd ..
- name: Run benchmarks on Rust ${{ matrix.toolchain }}
run: |
cd bench
RUSTFLAGS="--cfg=ldk_bench --cfg=require_route_graph_test" cargo bench
- - name: Run benchmarks with hashbrown on Rust ${{ matrix.toolchain }}
- run: |
- cd bench
- RUSTFLAGS="--cfg=ldk_bench --cfg=require_route_graph_test" cargo bench --features hashbrown
check_commits:
runs-on: ubuntu-latest
- name: Run cargo check for release build.
run: |
cargo check --release
- cargo check --no-default-features --features=no-std --release
cargo check --no-default-features --features=futures,std --release
cargo doc --release
- name: Run cargo check for Taproot build.
run: |
cargo check --release
- cargo check --no-default-features --features=no-std --release
+ cargo check --no-default-features --release
cargo check --no-default-features --features=futures,std --release
cargo doc --release
+ cargo doc --no-default-features --release
env:
RUSTFLAGS: '--cfg=taproot'
RUSTDOCFLAGS: '--cfg=taproot'
[workspace]
resolver = "2"
+# When the workspace members change, make sure to update the list here as well
+# as in `ci/ci-tests.sh`.
members = [
"lightning",
"lightning-types",
-----------
1. [lightning](./lightning)
The core of the LDK library, implements the Lightning protocol, channel state machine,
- and on-chain logic. Supports `no-std` and exposes only relatively low-level interfaces.
+ and on-chain logic. Supports `no_std` and exposes only relatively low-level interfaces.
2. [lightning-background-processor](./lightning-background-processor)
Utilities to perform required background tasks for Rust Lightning.
3. [lightning-block-sync](./lightning-block-sync)
name = "bench"
harness = false
-[features]
-hashbrown = ["lightning/hashbrown"]
-
[dependencies]
lightning = { path = "../lightning", features = ["_test_utils", "criterion"] }
lightning-persister = { path = "../lightning-persister", features = ["criterion"] }
This crate uses criterion to benchmark various LDK functions.
It can be run as `RUSTFLAGS=--cfg=ldk_bench cargo bench`.
-
-For routing or other HashMap-bottlenecked functions, the `hashbrown` feature
-should also be benchmarked.
cargo doc
cargo doc --document-private-items
cd fuzz && RUSTFLAGS="--cfg=fuzzing --cfg=secp256k1_fuzz --cfg=hashes_fuzz" cargo check --features=stdin_fuzz
-cd ../lightning && cargo check --no-default-features --features=no-std
+cd ../lightning && cargo check --no-default-features
cd .. && RUSTC_BOOTSTRAP=1 RUSTFLAGS="--cfg=c_bindings" cargo check -Z avoid-dev-deps
echo -e "\n\nChecking the full workspace."
cargo check --verbose --color always
+# When the workspace members change, make sure to update the list here as well
+# as in `Cargo.toml`.
WORKSPACE_MEMBERS=(
lightning
lightning-types
RUSTFLAGS="$RUSTFLAGS -A unused_variables -A unused_macros -A unused_imports -A dead_code" cargo check -p lightning --verbose --color always --features "$FEATURE"
done
-echo -e "\n\nTesting no-std builds"
+echo -e "\n\nTesting no_std builds"
for DIR in lightning-invoice lightning-rapid-gossip-sync; do
cargo test -p $DIR --verbose --color always --no-default-features
done
-cargo test -p lightning --verbose --color always --no-default-features --features no-std
-# check if there is a conflict between no-std and the default std feature
-cargo test -p lightning --verbose --color always --features no-std
+cargo test -p lightning --verbose --color always --no-default-features
echo -e "\n\nTesting c_bindings builds"
# Note that because `$RUSTFLAGS` is not passed through to doctest builds we cannot selectively
RUSTFLAGS="$RUSTFLAGS --cfg=c_bindings" cargo test --verbose --color always --lib --bins --tests
for DIR in lightning-invoice lightning-rapid-gossip-sync; do
- # check if there is a conflict between no-std and the c_bindings cfg
+ # check if there is a conflict between no_std and the c_bindings cfg
RUSTFLAGS="$RUSTFLAGS --cfg=c_bindings" cargo test -p $DIR --verbose --color always --no-default-features
done
# Note that because `$RUSTFLAGS` is not passed through to doctest builds we cannot selectively
# disable doctests in `c_bindings` so we skip doctests entirely here.
RUSTFLAGS="$RUSTFLAGS --cfg=c_bindings" cargo test -p lightning-background-processor --verbose --color always --features futures --no-default-features --lib --bins --tests
-RUSTFLAGS="$RUSTFLAGS --cfg=c_bindings" cargo test -p lightning --verbose --color always --no-default-features --features=no-std --lib --bins --tests
+RUSTFLAGS="$RUSTFLAGS --cfg=c_bindings" cargo test -p lightning --verbose --color always --no-default-features --lib --bins --tests
echo -e "\n\nTesting other crate-specific builds"
# Note that outbound_commitment_test only runs in this mode because of hardcoded signature values
RUSTFLAGS="$RUSTFLAGS --cfg=ldk_test_vectors" cargo test -p lightning --verbose --color always --no-default-features --features=std
# This one only works for lightning-invoice
-# check that compile with no-std and serde works in lightning-invoice
+# check that compile with no_std and serde works in lightning-invoice
cargo test -p lightning-invoice --verbose --color always --no-default-features --features serde
-echo -e "\n\nTesting no-std build on a downstream no-std crate"
+echo -e "\n\nTesting no_std build on a downstream no-std crate"
# check no-std compatibility across dependencies
pushd no-std-check
cargo check --verbose --color always --features lightning-transaction-sync
stdin_fuzz = []
[dependencies]
-lightning = { path = "../lightning", features = ["regex", "hashbrown", "_test_utils"] }
+lightning = { path = "../lightning", features = ["regex", "_test_utils"] }
lightning-invoice = { path = "../lightning-invoice" }
lightning-rapid-gossip-sync = { path = "../lightning-rapid-gossip-sync" }
bech32 = "0.9.1"
//! Utilities that take care of tasks that (1) need to happen periodically to keep Rust-Lightning
-//! running properly, and (2) either can or should be run in the background. See docs for
-//! [`BackgroundProcessor`] for more details on the nitty-gritty.
-
+//! running properly, and (2) either can or should be run in the background.
+#![cfg_attr(feature = "std", doc = "See docs for [`BackgroundProcessor`] for more details.")]
#![deny(rustdoc::broken_intra_doc_links)]
#![deny(rustdoc::private_intra_doc_links)]
#![deny(missing_docs)]
//! Note that the first ever rapid sync should use `0` for `last_sync_timestamp`.
//!
//! After the gossip data snapshot has been downloaded, one of the client's graph processing
-//! functions needs to be called. In this example, we process the update by reading its contents
-//! from disk, which we do by calling [`RapidGossipSync::update_network_graph`]:
+//! functions needs to be called.
+#![cfg_attr(
+ feature = "std",
+ doc = "In this example, we process the update by reading its contents from disk, which we do by calling [`RapidGossipSync::update_network_graph`]:"
+)]
+#![cfg_attr(
+ not(feature = "std"),
+ doc = "In this example, we process the update by reading its contents from disk, which we do by calling [`RapidGossipSync::update_network_graph_no_std`]:"
+)]
//!
//! ```
//! use bitcoin::constants::genesis_block;
//! let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
//! let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
//! let snapshot_contents: &[u8] = &[0; 0];
-//! // In no-std you need to provide the current time in unix epoch seconds
-//! // otherwise you can use update_network_graph
-//! let current_time_unix = 0;
-//! let new_last_sync_timestamp_result = rapid_sync.update_network_graph_no_std(snapshot_contents, Some(current_time_unix));
+//! // In non-`std` environments you need to provide the current time in unix epoch seconds
+//! // otherwise you can use `update_network_graph`:
+#![cfg_attr(
+ feature = "std",
+ doc = "let new_last_sync_timestamp_result = rapid_sync.update_network_graph(snapshot_contents);"
+)]
+#![cfg_attr(not(feature = "std"), doc = "let current_time_unix = 0;")]
+#![cfg_attr(
+ not(feature = "std"),
+ doc = "let new_last_sync_timestamp_result = rapid_sync.update_network_graph_no_std(snapshot_contents, Some(current_time_unix));"
+)]
//! ```
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
# This is unsafe to use in production because it may result in the counterparty publishing taking our funds.
unsafe_revoked_tx_signing = []
-no-std = ["hashbrown", "possiblyrandom", "libm"]
std = []
# Generates low-r bitcoin signatures, which saves 1 byte in 50% of the cases
bech32 = { version = "0.9.1", default-features = false }
bitcoin = { version = "0.32.2", default-features = false, features = ["secp-recovery"] }
-hashbrown = { version = "0.13", optional = true, default-features = false }
-possiblyrandom = { version = "0.2", path = "../possiblyrandom", optional = true, default-features = false }
+hashbrown = { version = "0.13", default-features = false }
+possiblyrandom = { version = "0.2", path = "../possiblyrandom", default-features = false }
regex = { version = "1.5.6", optional = true }
backtrace = { version = "0.3", optional = true }
-libm = { version = "0.2", optional = true, default-features = false }
+libm = { version = "0.2", default-features = false }
[dev-dependencies]
regex = "1.5.6"
///
/// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
UserAbandoned,
- /// We exhausted all of our retry attempts while trying to send the payment, or we
- /// exhausted the [`Retry::Timeout`] if the user set one. If at any point a retry
- /// attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
+ #[cfg_attr(feature = "std", doc = "We exhausted all of our retry attempts while trying to send the payment, or we")]
+ #[cfg_attr(feature = "std", doc = "exhausted the [`Retry::Timeout`] if the user set one.")]
+ #[cfg_attr(not(feature = "std"), doc = "We exhausted all of our retry attempts while trying to send the payment.")]
+ /// If at any point a retry attempt failed while being forwarded along the path, an [`Event::PaymentPathFailed`] will
/// have come before this.
- ///
- /// [`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout
+ #[cfg_attr(feature = "std", doc = "")]
+ #[cfg_attr(feature = "std", doc = "[`Retry::Timeout`]: crate::ln::channelmanager::Retry::Timeout")]
RetriesExhausted,
/// The payment expired while retrying, based on the provided
/// [`PaymentParameters::expiry_time`].
//!
//! * `std`
//! * `grind_signatures`
-//! * `no-std ` - exposes write trait implementations from the `core2` crate (at least one of `no-std` or `std` are required)
//! * Skip logging of messages at levels below the given log level:
//! * `max_level_off`
//! * `max_level_error`
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
-#[cfg(not(any(feature = "std", feature = "no-std")))]
-compile_error!("at least one of the `std` or `no-std` features must be enabled");
-
#[cfg(all(fuzzing, test))]
compile_error!("Tests will always fail with cfg=fuzzing");
/// * Forgetting about stale outbound payments, either those that have already been fulfilled
/// or those awaiting an invoice that hasn't been delivered in the necessary amount of time.
/// The latter is determined using the system clock in `std` and the highest seen block time
- /// minus two hours in `no-std`.
+ /// minus two hours in non-`std`.
///
/// Note that this may cause reentrancy through [`chain::Watch::update_channel`] calls or feerate
/// estimate fetches.
/// See [Avoiding Duplicate Payments] for other requirements once the payment has been sent.
///
/// The builder will have the provided expiration set. Any changes to the expiration on the
- /// returned builder will not be honored by [`ChannelManager`]. For `no-std`, the highest seen
+ /// returned builder will not be honored by [`ChannelManager`]. For non-`std`, the highest seen
/// block time minus two hours is used for the current time when determining if the refund has
/// expired.
///
/// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
/// [`PhantomRouteHints::channels`]: crate::ln::channelmanager::PhantomRouteHints::channels
/// [`MIN_FINAL_CLTV_EXPIRY_DETLA`]: crate::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA
-///
-/// This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
-/// available and the current time is supplied by the caller.
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not available and the current time is supplied by the caller.")]
pub fn create_phantom_invoice<ES: Deref, NS: Deref, L: Deref>(
amt_msat: Option<u64>, payment_hash: Option<PaymentHash>, description: String,
invoice_expiry_delta_secs: u32, phantom_route_hints: Vec<PhantomRouteHints>, entropy_source: ES,
/// [`ChannelManager::create_inbound_payment`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment
/// [`ChannelManager::create_inbound_payment_for_hash`]: crate::ln::channelmanager::ChannelManager::create_inbound_payment_for_hash
/// [`PhantomRouteHints::channels`]: crate::ln::channelmanager::PhantomRouteHints::channels
-///
-/// This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
-/// available and the current time is supplied by the caller.
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not available and the current time is supplied by the caller.")]
pub fn create_phantom_invoice_with_description_hash<ES: Deref, NS: Deref, L: Deref>(
amt_msat: Option<u64>, payment_hash: Option<PaymentHash>, invoice_expiry_delta_secs: u32,
description_hash: Sha256, phantom_route_hints: Vec<PhantomRouteHints>, entropy_source: ES,
)
}
-/// See [`create_invoice_from_channelmanager_with_description_hash`]
-/// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
-/// available and the current time is supplied by the caller.
+/// Utility to construct an invoice. Generally, unless you want to do something like a custom
+/// `cltv_expiry`, this is what you should be using to create an invoice.
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "See [`create_invoice_from_channelmanager_with_description_hash`] for more information.")]
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "This can be used in a `no_std` environment, where [`std::time::SystemTime`] is not available and the current time is supplied by the caller.")]
pub fn create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, ES, NS, SP, F, R, L>, node_signer: NS, logger: L,
network: Currency, amt_msat: Option<u64>, description_hash: Sha256,
)
}
-/// See [`create_invoice_from_channelmanager`]
-/// This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not
-/// available and the current time is supplied by the caller.
+/// Utility to construct an invoice. Generally, unless you want to do something like a custom
+/// `cltv_expiry`, this is what you should be using to create an invoice.
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "See [`create_invoice_from_channelmanager`] for more information.")]
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "This version can be used in a `no_std` environment, where [`std::time::SystemTime`] is not available and the current time is supplied by the caller.")]
pub fn create_invoice_from_channelmanager_and_duration_since_epoch<M: Deref, T: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref>(
channelmanager: &ChannelManager<M, T, ES, NS, SP, F, R, L>, node_signer: NS, logger: L,
network: Currency, amt_msat: Option<u64>, description: String, duration_since_epoch: Duration,
ShortRead,
/// A length descriptor in the packet didn't describe the later data correctly.
BadLengthDescriptor,
- /// Error from [`std::io`].
+ /// Error from [`crate::io`].
Io(io::ErrorKind),
/// The message included zlib-compressed values, which we don't support.
UnsupportedCompression,
/// [`Event::PaymentFailed`]: crate::events::Event::PaymentFailed
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RetryableSendFailure {
- /// The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired. Note
- /// that this error is *not* caused by [`Retry::Timeout`].
+ /// The provided [`PaymentParameters::expiry_time`] indicated that the payment has expired.
+ #[cfg_attr(feature = "std", doc = "")]
+ #[cfg_attr(feature = "std", doc = "Note that this error is *not* caused by [`Retry::Timeout`].")]
///
/// [`PaymentParameters::expiry_time`]: crate::routing::router::PaymentParameters::expiry_time
PaymentExpired,
#[doc = concat!("Sets the [`", stringify!($invoice_type), "::relative_expiry`]")]
#[doc = concat!("as seconds since [`", stringify!($invoice_type), "::created_at`].")]
#[doc = "Any expiry that has already passed is valid and can be checked for using"]
- #[doc = concat!("[`", stringify!($invoice_type), "::is_expired`].")]
+ #[cfg_attr(feature = "std", doc = concat!("[`", stringify!($invoice_type), "::is_expired`]."))]
///
/// Successive calls to this method will override the previous setting.
pub fn relative_expiry($($self_mut)* $self: $self_type, relative_expiry_secs: u32) -> $return_type {
/// Keys used for signing a [`Bolt12Invoice`] if they can be derived.
///
- /// If `Some`, must call [`respond_using_derived_keys`] when responding. Otherwise, call
- /// [`respond_with`].
- ///
+ #[cfg_attr(feature = "std", doc = "If `Some`, must call [`respond_using_derived_keys`] when responding. Otherwise, call [`respond_with`].")]
+ #[cfg_attr(feature = "std", doc = "")]
/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
- /// [`respond_using_derived_keys`]: Self::respond_using_derived_keys
- /// [`respond_with`]: Self::respond_with
+ #[cfg_attr(feature = "std", doc = "[`respond_using_derived_keys`]: Self::respond_using_derived_keys")]
+ #[cfg_attr(feature = "std", doc = "[`respond_with`]: Self::respond_with")]
pub keys: Option<Keypair>,
}
/// Creates an [`InvoiceBuilder`] for the request with the given required fields.
///
/// Unless [`InvoiceBuilder::relative_expiry`] is set, the invoice will expire two hours after
- /// `created_at`, which is used to set [`Bolt12Invoice::created_at`]. Useful for `no-std` builds
- /// where [`std::time::SystemTime`] is not available.
+ /// `created_at`, which is used to set [`Bolt12Invoice::created_at`].
+ #[cfg_attr(feature = "std", doc = "Useful for non-`std` builds where [`std::time::SystemTime`] is not available.")]
///
/// The caller is expected to remember the preimage of `payment_hash` in order to claim a payment
/// for the invoice.
$return_value
}
- /// Sets the [`Offer::absolute_expiry`] as seconds since the Unix epoch. Any expiry that has
- /// already passed is valid and can be checked for using [`Offer::is_expired`].
+ /// Sets the [`Offer::absolute_expiry`] as seconds since the Unix epoch.
+ #[cfg_attr(feature = "std", doc = "Any expiry that has already passed is valid and can be checked for using [`Offer::is_expired`].")]
///
/// Successive calls to this method will override the previous setting.
pub fn absolute_expiry($($self_mut)* $self: $self_type, absolute_expiry: Duration) -> $return_type {
/// Error when interpreting a TLV stream as a specific type.
#[derive(Clone, Debug, PartialEq)]
pub enum Bolt12SemanticError {
- /// The current [`std::time::SystemTime`] is past the offer or invoice's expiration.
+ /// The current system time is past the offer or invoice's expiration.
AlreadyExpired,
/// The provided chain hash does not correspond to a supported chain.
UnsupportedChain,
$return_value
}
- /// Sets the [`Refund::absolute_expiry`] as seconds since the Unix epoch. Any expiry that has
- /// already passed is valid and can be checked for using [`Refund::is_expired`].
+ /// Sets the [`Refund::absolute_expiry`] as seconds since the Unix epoch.
+ #[cfg_attr(feature = "std", doc = "Any expiry that has already passed is valid and can be checked for using [`Refund::is_expired`].")]
///
/// Successive calls to this method will override the previous setting.
pub fn absolute_expiry($($self_mut)* $self: $self_type, absolute_expiry: Duration) -> $return_type {
/// Creates an [`InvoiceBuilder`] for the refund with the given required fields.
///
/// Unless [`InvoiceBuilder::relative_expiry`] is set, the invoice will expire two hours after
- /// `created_at`, which is used to set [`Bolt12Invoice::created_at`]. Useful for `no-std` builds
- /// where [`std::time::SystemTime`] is not available.
+ /// `created_at`, which is used to set [`Bolt12Invoice::created_at`].
+ #[cfg_attr(feature = "std", doc = "Useful for non-`std` builds where [`std::time::SystemTime`] is not available.")]
///
/// The caller is expected to remember the preimage of `payment_hash` in order to
/// claim a payment for the invoice.
//
// NOTE: In the following `removed_*` maps, we use seconds since UNIX epoch to track time instead
// of `std::time::Instant`s for a few reasons:
- // * We want it to be possible to do tracking in no-std environments where we can compare
+ // * We want it to be possible to do tracking in non-`std` environments where we can compare
// a provided current UNIX timestamp with the time at which we started tracking.
// * In the future, if we decide to persist these maps, they will already be serializable.
// * Although we lose out on the platform's monotonic clock, the system clock in a std
// our peers and never receiving gossip from peers at all, we send all of our peers a
// `gossip_timestamp_filter`, with the filter time set either two weeks ago or an hour ago.
//
- // For no-std builds, we bury our head in the sand and do a full sync on each connection.
+ // For non-`std` builds, we bury our head in the sand and do a full sync on each connection.
#[allow(unused_mut, unused_assignments)]
let mut gossip_start_time = 0;
#[allow(unused)]
/// Not stored if contains excess data to prevent DoS.
pub announcement_message: Option<ChannelAnnouncement>,
/// The timestamp when we received the announcement, if we are running with feature = "std"
- /// (which we can probably assume we are - no-std environments probably won't have a full
+ /// (which we can probably assume we are - non-`std` environments probably won't have a full
/// network graph in memory!).
announcement_received_time: u64,
}
/// in the map for a while so that these can be resynced from gossip in the future.
///
/// This method is only available with the `std` feature. See
- /// [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] for `no-std` use.
+ /// [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] for non-`std` use.
pub fn remove_stale_channels_and_tracking(&self) {
let time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs();
self.remove_stale_channels_and_tracking_with_time(time);
///
/// This method will also cause us to stop tracking removed nodes and channels if they have been
/// in the map for a while so that these can be resynced from gossip in the future.
- ///
- /// This function takes the current unix time as an argument. For users with the `std` feature
- /// enabled, [`NetworkGraph::remove_stale_channels_and_tracking`] may be preferable.
+ #[cfg_attr(feature = "std", doc = "")]
+ #[cfg_attr(feature = "std", doc = "This function takes the current unix time as an argument. For users with the `std` feature")]
+ #[cfg_attr(feature = "std", doc = "enabled, [`NetworkGraph::remove_stale_channels_and_tracking`] may be preferable.")]
pub fn remove_stale_channels_and_tracking_with_time(&self, current_time_unix: u64) {
let mut channels = self.channels.write().unwrap();
// Time out if we haven't received an update in at least 14 days.
if let Some(time) = time {
current_time_unix.saturating_sub(*time) < REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS
} else {
- // NOTE: In the case of no-std, we won't have access to the current UNIX time at the time of removal,
+ // NOTE: In the case of non-`std`, we won't have access to the current UNIX time at the time of removal,
// so we'll just set the removal time here to the current UNIX time on the very next invocation
// of this function.
#[cfg(not(feature = "std"))]
/// [`RoutingMessageHandler`] implementation to call it indirectly. This may be useful to accept
/// routing messages from a source using a protocol other than the lightning P2P protocol.
///
- /// If built with `no-std`, any updates with a timestamp more than two weeks in the past or
+ /// If not built with `std`, any updates with a timestamp more than two weeks in the past or
/// materially in the future will be rejected.
pub fn update_channel(&self, msg: &msgs::ChannelUpdate) -> Result<(), LightningError> {
self.update_channel_internal(&msg.contents, Some(&msg), Some(&msg.signature), false)
/// of the channel without verifying the associated signatures. Because we aren't given the
/// associated signatures here we cannot relay the channel update to any of our peers.
///
- /// If built with `no-std`, any updates with a timestamp more than two weeks in the past or
+ /// If not built with `std`, any updates with a timestamp more than two weeks in the past or
/// materially in the future will be rejected.
pub fn update_channel_unsigned(&self, msg: &msgs::UnsignedChannelUpdate) -> Result<(), LightningError> {
self.update_channel_internal(msg, None, None, false)
///
/// This checks whether the update currently is applicable by [`Self::update_channel`].
///
- /// If built with `no-std`, any updates with a timestamp more than two weeks in the past or
+ /// If not built with `std`, any updates with a timestamp more than two weeks in the past or
/// materially in the future will be rejected.
pub fn verify_channel_update(&self, msg: &msgs::ChannelUpdate) -> Result<(), LightningError> {
self.update_channel_internal(&msg.contents, Some(&msg), Some(&msg.signature), true)
///
/// # Note
///
- /// When built with the `no-std` feature, time will never elapse. Therefore, the channel
+ /// When not built with the `std` feature, time will never elapse. Therefore, the channel
/// liquidity knowledge will never decay except when the bounds cross.
pub liquidity_offset_half_life: Duration,
}
-//! Generally LDK uses `std`'s `HashMap`s, however when building for no-std, LDK uses `hashbrown`'s
-//! `HashMap`s with the `std` `SipHasher` and uses `getrandom` to opportunistically randomize it,
-//! if randomization is available.
+//! Generally LDK uses `hashbrown`'s `HashMap`s with the `std` `SipHasher` and uses `getrandom` to
+//! opportunistically randomize it, if randomization is available.
//!
//! This module simply re-exports the `HashMap` used in LDK for public consumption.
-#[cfg(feature = "hashbrown")]
-extern crate hashbrown;
-#[cfg(feature = "possiblyrandom")]
-extern crate possiblyrandom;
+pub(crate) use hashbrown::hash_map;
-// For no-std builds, we need to use hashbrown, however, by default, it doesn't randomize the
-// hashing and is vulnerable to HashDoS attacks. Thus, we use the core SipHasher when not using
-// std, but use `getrandom` to randomize it if its available.
-
-#[cfg(not(feature = "hashbrown"))]
-mod std_hashtables {
- pub use std::collections::hash_map::RandomState;
- pub use std::collections::HashMap;
-
- pub(crate) use std::collections::{hash_map, HashSet};
-
- pub(crate) type OccupiedHashMapEntry<'a, K, V> =
- std::collections::hash_map::OccupiedEntry<'a, K, V>;
- pub(crate) type VacantHashMapEntry<'a, K, V> =
- std::collections::hash_map::VacantEntry<'a, K, V>;
-
- /// Builds a new [`HashMap`].
- pub fn new_hash_map<K, V>() -> HashMap<K, V> {
- HashMap::new()
- }
- /// Builds a new [`HashMap`] with the given capacity.
- pub fn hash_map_with_capacity<K, V>(cap: usize) -> HashMap<K, V> {
- HashMap::with_capacity(cap)
- }
- pub(crate) fn hash_map_from_iter<
- K: core::hash::Hash + Eq,
- V,
- I: IntoIterator<Item = (K, V)>,
- >(
- iter: I,
- ) -> HashMap<K, V> {
- HashMap::from_iter(iter)
- }
-
- pub(crate) fn new_hash_set<K>() -> HashSet<K> {
- HashSet::new()
- }
- pub(crate) fn hash_set_with_capacity<K>(cap: usize) -> HashSet<K> {
- HashSet::with_capacity(cap)
- }
- pub(crate) fn hash_set_from_iter<K: core::hash::Hash + Eq, I: IntoIterator<Item = K>>(
- iter: I,
- ) -> HashSet<K> {
- HashSet::from_iter(iter)
- }
-}
-#[cfg(not(feature = "hashbrown"))]
-pub use std_hashtables::*;
-
-#[cfg(feature = "hashbrown")]
-pub(crate) use self::hashbrown::hash_map;
-
-#[cfg(feature = "hashbrown")]
mod hashbrown_tables {
#[cfg(feature = "std")]
mod hasher {
/// target platform.
pub fn new() -> RandomState {
let (k0, k1);
- #[cfg(all(not(fuzzing), feature = "possiblyrandom"))]
+ #[cfg(not(fuzzing))]
{
let mut keys = [0; 16];
possiblyrandom::getpossiblyrandom(&mut keys);
k0 = u64::from_le_bytes(k0_bytes);
k1 = u64::from_le_bytes(k1_bytes);
}
- #[cfg(any(fuzzing, not(feature = "possiblyrandom")))]
+ #[cfg(fuzzing)]
{
k0 = 0;
k1 = 0;
}
}
- use super::*;
pub use hasher::*;
/// The HashMap type used in LDK.
res
}
}
-#[cfg(feature = "hashbrown")]
+
pub use hashbrown_tables::*;
/// serialization buffer size
pub const MAX_BUF_SIZE: usize = 64 * 1024;
-/// A simplified version of [`std::io::Write`] that exists largely for backwards compatibility.
-/// An impl is provided for any type that also impls [`std::io::Write`].
+/// A simplified version of `std::io::Write` that exists largely for backwards compatibility.
+/// An impl is provided for any type that also impls `std::io::Write`.
///
/// This is not exported to bindings users as we only export serialization to/from byte arrays instead
pub trait Writer {
}
}
-/// Essentially [`std::io::Take`] but a bit simpler and with a method to walk the underlying stream
+/// Essentially `std::io::Take` but a bit simpler and with a method to walk the underlying stream
/// forward to ensure we always consume exactly the fixed length specified.
///
/// This is not exported to bindings users as manual TLV building is not currently supported in bindings
///
/// [`Readable`]: crate::util::ser::Readable
/// [`Writeable`]: crate::util::ser::Writeable
+/// [`Vec`]: crate::prelude::Vec
#[macro_export]
macro_rules! impl_writeable_tlv_based {
($st: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
#[allow(unused_mut, unused_assignments)]
let mut gossip_start_time = 0;
- #[cfg(not(feature = "no-std"))]
+ #[cfg(feature = "std")]
{
use std::time::{SystemTime, UNIX_EPOCH};
gossip_start_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs();
/// A callback which is called when a [`Future`] completes.
///
/// Note that this MUST NOT call back into LDK directly, it must instead schedule actions to be
-/// taken later. Rust users should use the [`std::future::Future`] implementation for [`Future`]
-/// instead.
-///
-/// Note that the [`std::future::Future`] implementation may only work for runtimes which schedule
-/// futures when they receive a wake, rather than immediately executing them.
+/// taken later.
+#[cfg_attr(feature = "std", doc = "Rust users should use the [`std::future::Future`] implementation for [`Future`] instead.")]
+#[cfg_attr(feature = "std", doc = "")]
+#[cfg_attr(feature = "std", doc = "Note that the [`std::future::Future`] implementation may only work for runtimes which schedule futures when they receive a wake, rather than immediately executing them.")]
pub trait FutureCallback : $($bounds +)* {
/// The method which is called.
fn call(&self);
edition = "2021"
[features]
-default = ["lightning/no-std"]
+default = []
[dependencies]
lightning = { path = "../lightning", default-features = false }
projects / rust-lightning / commitdiff