V1 complete minus more links in guide

Author: valentinewallace

docs/custom_blockdata.md renamed to docs/blockdata.md

@@ -1,5 +1,5 @@
 ---
-id: custom_blockdata
+id: blockdata
 title: Blockchain Data
 ---
 

docs/build_node.md

@@ -2,5 +2,55 @@
 id: getting_started
 title: Getting Started
 ---
+import useBaseUrl from '@docusaurus/useBaseUrl';
 
-TODO
+## Introduction
+
+This guide will give an entrypoint to LDK as a whole, an introduction to the architecture of LDK and what
+batteries need to be plugged into it to get it working. These batteries
+can be supplied by the user or by one of LDK's sample modules.
+
+## How To Use These Docs
+"Getting Started" + "Overview" provide an introduction to the architecture and
+design philosophy of LDK. 
+
+"Build a Node: Checklist" walks through how to specifically integrate LDK into
+your application, as well as documentation for what features are currently available
+and not available for LDK in Java. "Opening a Channel" is a follow-up to "Build a Node"
+that walks through an example of opening a channel with LDK.
+
+"Key Management", "Spending On-Chain Funds", and "Block Data" dive into more depth on their topics.
+
+Throughout these docs, if any piece of code is used or mentioned, the most in-depth docs can be
+found by searching [the Rust docs](https://docs.rs/lightning/0.0.12/lightning/index.html).
+
+## Architecture
+<img alt="LDK Architecture" src={useBaseUrl('img/ldk_arch.svg')} />
+
+The big blue box in the center contains all of LDK's core objects.
+
+The green boxes and Data Storage are all of LDK's batteries that must be provided.
+
+## LDK Batteries
+
+This section will be updated as support for LDK batteries changes.
+* Networking (lightning-net-tokio in the diagram)
+  * Sample modules are available in [Rust](https://github.com/rust-bitcoin/rust-lightning/tree/main/lightning-net-tokio) and [Java](https://github.com/lightningdevkit/ldk-garbagecollected/tree/main/src/main/java/org/ldk/batteries)
+* KeysManager
+  * LDK supplies an implementation called [KeysManager](https://docs.rs/lightning/0.0.10/lightning/chain/keysinterface/struct.KeysManager.html)
+* Data storage
+  * sample module is available in [Rust](https://github.com/rust-bitcoin/rust-lightning/tree/main/lightning-persister)
+* BlockSource
+  * sample module is almost available in [Rust](https://github.com/rust-bitcoin/rust-lightning/pull/763)
+* Randomness
+  * currently only supplied by the user
+* FeeEstimator
+  * currently only supplied by the user
+* TxFilter
+  * currently only supplied by the user
+* TxBroadcaster
+  * currently only supplied by the user
+  
+EventHandler in the diagram is not so much a necessary LDK battery, but instead
+refers to the fact that LDK generates events that the user should handle (e.g.
+the `PaymentReceived` event).

docs/custom_key_mgmt.md

@@ -0,0 +1,15 @@
+---
+id: key_mgmt
+title: Key Management
+---
+Relevant reference: https://docs.rs/lightning/0.0.12/lightning/chain/keysinterface/struct.KeysManager.html
+
+LDK Private Key Information is primarily provided through the `chain::keysinterface::KeysInterface` trait. It includes a few basic methods to get public and private key information, as well as a method to get an instance of a second trait which provides per-channel information - `chain::keysinterface::ChannelKeys`. While a custom `KeysInterface` implementation allows simple flexibility to control derivation of private keys, `ChannelKeys` focuses on signing lightning transactions and is primarily useful if you want to store private key material on a separate device which enforces lightning protocol details.
+A simple implementation of `KeysInterface` is provided in the form of `chain::keysinterface::KeysManager`, see its documentation for more details on its key derivation. It uses `chain::keysinterface::InMemoryChannelKeys` for channel signing, which is likely an appropriate signer for custom `KeysInterface` implementations as well.
+A `KeysManager` can be constructed simply with only a 32-byte seed and some integers which ensure uniqueness across restarts (defined as `starting_time_secs` and `starting_time_nanos`).
+```rust
+let mut random_32_bytes = [0; 32];
+// Fill in random_32_bytes with secure random data, or, on restart, reload the seed from disk.
+let start_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+let keys_interface_impl = lightning::chain::keysinterface::KeysManager::new(random_32-bytes, bitcoin::network::constants::Network::Bitcoin, start_time.as_secs(), start_time.subsec_nanos());
+```

docs/getting_started.md

@@ -0,0 +1,7 @@
+---
+id: onchain_funds
+title: "Spending On-chain Funds"
+---
+Relevant reference: search for any structs or methods mentioned in this article [here](https://docs.rs/lightning/0.0.12/lightning/index.html).
+
+When a channel has been closed and some outputs on chain are spendable only by us, LDK provides a `util::events::Event::SpendableOutputs` event in return from `ChannelMonitor::get_and_clear_pending_events()`. It contains a list of `chain::keysinterface::SpendableOutputDescriptor` objects which describe the output and provide all necessary information to spend it. `ChannelKeys` objects provide a unique id via the `key_derivation_params` function, who's value is provided back to you in the `SpendableOutputs` objects. For users of a `KeysManager` object, you can re-construct the `InMemoryChannelKeys` object using this information and fetch the relevant private keys from that. A `SpendableOutputDescriptor::StaticOutput` element does not have this information as the output is sent to an output which used only `KeysInterface` data, not per-channel data.

docs/key_mgmt.md

@@ -0,0 +1,55 @@
+---
+id: open_channel
+title: "Opening a Channel with LDK"
+---
+
+## Prerequisites
+See "Build a Node: Checklist" for preparing LDK to open a channel. This guide 
+is a follow-up.
+
+## Overview
+This guide is more of a walkthrough of a code snippet that shows the steps to
+open a channel with LDK.
+
+```java
+// <insert code to connect to peer via NioPeerHandler.connect(byte[] their_node_id, SocketAddress remote)>
+
+// Create the initial channel and make sure the result is successful.
+[]byte peer_node_pubkey = <peer node pubkey bytes>;
+Result_NoneAPIErrorZ create_channel_result = channel_manager.create_channel(
+    peer_node_pubkey, 10000, 1000, 42, null);
+assert create_channel_result instanceof Result_NoneAPIErrorZ.Result_NoneAPIErrorZ_OK;
+
+// Ensure this generates a FundingGenerationReady event and that its fields are 
+// sane.
+nio_peer_handler.check_events();
+Event[] events = channel_manager_events.get_and_clear_pending_events();
+assert events.length == 1;
+assert events[0] instanceof Event.FundingGenerationReady;
+assert ((Event.FundingGenerationReady) events[0]).channel_value_satoshis == 10000;
+assert ((Event.FundingGenerationReady) events[0]).user_channel_id == 42;
+byte[] funding_spk = ((Event.FundingGenerationReady) events[0]).output_script;
+assert funding_spk.length == 34 && funding_spk[0] == 0 && funding_spk[1] == 32; // P2WSH
+
+// Generate the funding transaction for the channel based on the channel amount
+NetworkParameters bitcoinj_net = NetworkParameters.fromID(NetworkParameters.ID_MAINNET);
+Transaction funding_tx = new Transaction(bitcoinj_net);
+funding_tx.addInput(new TransactionInput(bitcoinj_net, funding, new byte[0]));
+funding_tx.getInputs().get(0).setWitness(new TransactionWitness(2)); // Make sure we don't complain about lack of witness
+funding_tx.getInput(0).getWitness().setPush(0, new byte[]{0x1});
+funding_tx.addOutput(Coin.SATOSHI.multiply(10000), new Script(funding_spk));
+
+// Give the funding transaction back to the channel manager.
+byte[] chan_id = ((Event.FundingGenerationReady) events[0]).temporary_channel_id;
+channel_manager.funding_transaction_generated(chan_id, OutPoint.constructor_new(
+    funding_tx.getTxId().getReversedBytes(), (short) 0));
+
+// Ensure that the funding transaction is then broadcasted.
+nio_peer_handler.check_events();
+events = channel_manager_events.get_and_clear_pending_events();
+assert events.length == 1;
+assert events[0] instanceof Event.FundingBroadcastSafe;
+assert ((Event.FundingBroadcastSafe) events[0]).user_channel_id == 42;
+
+// Wait until a few blocks are mined, and then the channel is now open
+```

docs/onchain_funds.md

@@ -4,4 +4,7 @@ title: Overview
 slug: /
 ---
 
-TODO
+LDK is a flexible lightning implementation with supporting batteries (or modules).
+The core lightning implementation is Rust-Lightning.
+
+See the Rust-Lightning `README` for more overview: https://github.com/rust-bitcoin/rust-lightning

docs/open_channel.md

@@ -3,6 +3,15 @@ id: references
 title: References
 ---
 
-TODO
+* Rust documentation: https://docs.rs/lightning/0.0.12/lightning/index.html
+These provide the most searchable and comprehensive documentation on LDK.
+If you're using Java and want more information on any method/struct/etc., searching
+the Rust docs for the Rust version of that struct/method is your best bet.
 
-API docs, current sample node partial implementations
+* Rust sample node: https://github.com/TheBlueMatt/rust-lightning-bitcoinrpc
+While this node is a little outdated, it's still a very useful reference for how to construct
+a lightning node using LDK.
+
+* Swift LDK documentation: https://github.com/arik-so/SwiftLightning/tree/master/Documentation
+These docs are mainly geared towards how Swift could call LDK C bindings directly, but still may
+provide a useful overview of Rust Lightning in the context of language bindings.

docs/overview.md

@@ -1,6 +1,6 @@
 module.exports = {
   someSidebar: {
-      'Lightning Development Kit': ['overview', 'getting_started', 'use_cases', 'language_bindings', 'references'],
-      Guides: ['build_node', 'custom_persist', 'custom_key_mgmt', 'custom_blockdata'],
+      'Lightning Development Kit': ['overview', 'getting_started', 'use_cases', 'references'],
+      Guides: ['build_node', 'open_channel', 'key_mgmt', 'blockdata'],
   },
 };