X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Flightning_rapid_gossip_sync%2Fmod.rs;fp=lightning-c-bindings%2Fsrc%2Flightning_rapid_gossip_sync%2Fmod.rs;h=0000000000000000000000000000000000000000;hp=6883b871636df2c7a722e69bab27cc1cf5788bbe;hb=0ac4dbdb8352c898100b34f0ef8ed9cebfea7786;hpb=c16401631dddadcefa37b05074ca7def51b85af4 diff --git a/lightning-c-bindings/src/lightning_rapid_gossip_sync/mod.rs b/lightning-c-bindings/src/lightning_rapid_gossip_sync/mod.rs deleted file mode 100644 index 6883b87..0000000 --- a/lightning-c-bindings/src/lightning_rapid_gossip_sync/mod.rs +++ /dev/null @@ -1,194 +0,0 @@ -// This file is Copyright its original authors, visible in version control -// history and in the source files from which this was generated. -// -// This file is licensed under the license available in the LICENSE or LICENSE.md -// file in the root of this repository or, if no such file exists, the same -// license as that which applies to the original source files from which this -// source was automatically generated. - -//! This crate exposes client functionality to rapidly sync gossip data, aimed primarily at mobile -//! devices. -//! -//! The rapid gossip sync server will provide a compressed response containing differential gossip -//! data. The gossip data is formatted compactly, omitting signatures and opportunistically -//! incremental where previous channel updates are known. This mechanism is enabled when the -//! timestamp of the last known channel update is communicated. A reference server implementation -//! can be found [on Github](https://github.com/lightningdevkit/rapid-gossip-sync-server). -//! -//! The primary benefit of this syncing mechanism is that it allows a low-powered client to offload -//! the validation of gossip signatures to a semi-trusted server. This enables the client to -//! privately calculate routes for payments, and to do so much faster than requiring a full -//! peer-to-peer gossip sync to complete. -//! -//! The server calculates its response on the basis of a client-provided `latest_seen` timestamp, -//! i.e., the server will return all rapid gossip sync data it has seen after the given timestamp. -//! -//! # Getting Started -//! Firstly, the data needs to be retrieved from the server. For example, you could use the server -//! at with the following request format: -//! -//! ```shell -//! curl -o rapid_sync.lngossip https://rapidsync.lightningdevkit.org/snapshot/ -//! ``` -//! 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`]: -//! -//! ``` -//! use bitcoin::blockdata::constants::genesis_block; -//! use bitcoin::Network; -//! use lightning::routing::gossip::NetworkGraph; -//! use lightning_rapid_gossip_sync::RapidGossipSync; -//! -//! # use lightning::util::logger::{Logger, Record}; -//! # struct FakeLogger {} -//! # impl Logger for FakeLogger { -//! # fn log(&self, record: &Record) { } -//! # } -//! # let logger = FakeLogger {}; -//! -//! 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)); -//! ``` - -use alloc::str::FromStr; -use alloc::string::String; -use core::ffi::c_void; -use core::convert::Infallible; -use bitcoin::hashes::Hash; -use crate::c_types::*; -#[cfg(feature="no-std")] -use alloc::{vec::Vec, boxed::Box}; - -pub mod error; -mod processing { - -use alloc::str::FromStr; -use alloc::string::String; -use core::ffi::c_void; -use core::convert::Infallible; -use bitcoin::hashes::Hash; -use crate::c_types::*; -#[cfg(feature="no-std")] -use alloc::{vec::Vec, boxed::Box}; - -} - -use lightning_rapid_gossip_sync::RapidGossipSync as nativeRapidGossipSyncImport; -pub(crate) type nativeRapidGossipSync = nativeRapidGossipSyncImport<&'static lightning::routing::gossip::NetworkGraph, crate::lightning::util::logger::Logger>; - -/// The main Rapid Gossip Sync object. -/// -/// See [crate-level documentation] for usage. -/// -/// [crate-level documentation]: crate -#[must_use] -#[repr(C)] -pub struct RapidGossipSync { - /// A pointer to the opaque Rust object. - - /// Nearly everywhere, inner must be non-null, however in places where - /// the Rust equivalent takes an Option, it may be set to null to indicate None. - pub inner: *mut nativeRapidGossipSync, - /// Indicates that this is the only struct which contains the same pointer. - - /// Rust functions which take ownership of an object provided via an argument require - /// this to be true and invalidate the object pointed to by inner. - pub is_owned: bool, -} - -impl Drop for RapidGossipSync { - fn drop(&mut self) { - if self.is_owned && !<*mut nativeRapidGossipSync>::is_null(self.inner) { - let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) }; - } - } -} -/// Frees any resources used by the RapidGossipSync, if is_owned is set and inner is non-NULL. -#[no_mangle] -pub extern "C" fn RapidGossipSync_free(this_obj: RapidGossipSync) { } -#[allow(unused)] -/// Used only if an object of this type is returned as a trait impl by a method -pub(crate) extern "C" fn RapidGossipSync_free_void(this_ptr: *mut c_void) { - let _ = unsafe { Box::from_raw(this_ptr as *mut nativeRapidGossipSync) }; -} -#[allow(unused)] -impl RapidGossipSync { - pub(crate) fn get_native_ref(&self) -> &'static nativeRapidGossipSync { - unsafe { &*ObjOps::untweak_ptr(self.inner) } - } - pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativeRapidGossipSync { - unsafe { &mut *ObjOps::untweak_ptr(self.inner) } - } - /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy - pub(crate) fn take_inner(mut self) -> *mut nativeRapidGossipSync { - assert!(self.is_owned); - let ret = ObjOps::untweak_ptr(self.inner); - self.inner = core::ptr::null_mut(); - ret - } -} -/// Instantiate a new [`RapidGossipSync`] instance. -#[must_use] -#[no_mangle] -pub extern "C" fn RapidGossipSync_new(network_graph: &crate::lightning::routing::gossip::NetworkGraph, mut logger: crate::lightning::util::logger::Logger) -> crate::lightning_rapid_gossip_sync::RapidGossipSync { - let mut ret = lightning_rapid_gossip_sync::RapidGossipSync::new(network_graph.get_native_ref(), logger); - crate::lightning_rapid_gossip_sync::RapidGossipSync { inner: ObjOps::heap_alloc(ret), is_owned: true } -} - -/// Sync gossip data from a file. -/// Returns the last sync timestamp to be used the next time rapid sync data is queried. -/// -/// `network_graph`: The network graph to apply the updates to -/// -/// `sync_path`: Path to the file where the gossip update data is located -/// -#[must_use] -#[no_mangle] -pub extern "C" fn RapidGossipSync_sync_network_graph_with_file_path(this_arg: &crate::lightning_rapid_gossip_sync::RapidGossipSync, mut sync_path: crate::c_types::Str) -> crate::c_types::derived::CResult_u32GraphSyncErrorZ { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.sync_network_graph_with_file_path(sync_path.into_str()); - let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_rapid_gossip_sync::error::GraphSyncError::native_into(e) }).into() }; - local_ret -} - -/// Update network graph from binary data. -/// Returns the last sync timestamp to be used the next time rapid sync data is queried. -/// -/// `update_data`: `&[u8]` binary stream that comprises the update data -#[must_use] -#[no_mangle] -pub extern "C" fn RapidGossipSync_update_network_graph(this_arg: &crate::lightning_rapid_gossip_sync::RapidGossipSync, mut update_data: crate::c_types::u8slice) -> crate::c_types::derived::CResult_u32GraphSyncErrorZ { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.update_network_graph(update_data.to_slice()); - let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_rapid_gossip_sync::error::GraphSyncError::native_into(e) }).into() }; - local_ret -} - -/// Update network graph from binary data. -/// Returns the last sync timestamp to be used the next time rapid sync data is queried. -/// -/// `update_data`: `&[u8]` binary stream that comprises the update data -/// `current_time_unix`: `Option` optional current timestamp to verify data age -#[must_use] -#[no_mangle] -pub extern "C" fn RapidGossipSync_update_network_graph_no_std(this_arg: &crate::lightning_rapid_gossip_sync::RapidGossipSync, mut update_data: crate::c_types::u8slice, mut current_time_unix: crate::c_types::derived::COption_u64Z) -> crate::c_types::derived::CResult_u32GraphSyncErrorZ { - let mut local_current_time_unix = if current_time_unix.is_some() { Some( { current_time_unix.take() }) } else { None }; - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.update_network_graph_no_std(update_data.to_slice(), local_current_time_unix); - let mut local_ret = match ret { Ok(mut o) => crate::c_types::CResultTempl::ok( { o }).into(), Err(mut e) => crate::c_types::CResultTempl::err( { crate::lightning_rapid_gossip_sync::error::GraphSyncError::native_into(e) }).into() }; - local_ret -} - -/// Returns whether a rapid gossip sync has completed at least once. -#[must_use] -#[no_mangle] -pub extern "C" fn RapidGossipSync_is_initial_sync_complete(this_arg: &crate::lightning_rapid_gossip_sync::RapidGossipSync) -> bool { - let mut ret = unsafe { &*ObjOps::untweak_ptr(this_arg.inner) }.is_initial_sync_complete(); - ret -} -