Move bdk_file_store into the bdk repo 🎉

Original repository: 250b4f1dcc/bdk_file_store

Co-authored-by: 志宇 <hello@evanlinjin.me>
Co-authored-by: LLFourn <lloyd.fourn@gmail.com>
Co-authored-by: Vladimir Fomene <vladimirfomene@gmail.com>

crates/file_store/tests/test_file_store.rs

@@ -0,0 +1,158 @@
+use bdk_chain::{
+    bitcoin::Transaction,
+    keychain::{KeychainChangeSet, KeychainTracker},
+    TxHeight,
+};
+use bdk_file_store::{FileError, IterError, KeychainStore, MAGIC_BYTES, MAGIC_BYTES_LEN};
+use serde;
+use std::{
+    format,
+    fs::{File, OpenOptions},
+    io::{Read, Write},
+    path::{Path, PathBuf},
+    vec::Vec,
+};
+
+struct TempPath(PathBuf);
+
+impl TempPath {
+    fn new() -> Self {
+        let now = std::time::UNIX_EPOCH
+            .elapsed()
+            .expect("must get epoch")
+            .as_nanos();
+        let mut file_path = std::env::temp_dir();
+        file_path.push(format!("bdk_test_{}", now));
+        Self(file_path)
+    }
+
+    fn open(&self) -> File {
+        OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(self.0.as_path())
+            .expect("must open")
+    }
+}
+
+impl AsRef<Path> for TempPath {
+    fn as_ref(&self) -> &Path {
+        self.0.as_path()
+    }
+}
+
+impl Drop for TempPath {
+    fn drop(&mut self) {
+        if let Err(e) = std::fs::remove_file(self.0.as_path()) {
+            if e.kind() != std::io::ErrorKind::NotFound {
+                panic!("remove file unexpected error: {}", e);
+            }
+        };
+    }
+}
+
+#[derive(
+    Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
+)]
+enum TestKeychain {
+    External,
+    Internal,
+}
+
+impl core::fmt::Display for TestKeychain {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::External => write!(f, "external"),
+            Self::Internal => write!(f, "internal"),
+        }
+    }
+}
+
+#[test]
+fn magic_bytes() {
+    assert_eq!(&MAGIC_BYTES, "bdkfs0000000".as_bytes());
+}
+
+#[test]
+fn new_fails_if_file_is_too_short() {
+    let path = TempPath::new();
+    path.open()
+        .write_all(&MAGIC_BYTES[..MAGIC_BYTES_LEN - 1])
+        .expect("should write");
+
+    match KeychainStore::<TestKeychain, TxHeight, Transaction>::new(path.open()) {
+        Err(FileError::Io(e)) => assert_eq!(e.kind(), std::io::ErrorKind::UnexpectedEof),
+        unexpected => panic!("unexpected result: {:?}", unexpected),
+    };
+}
+
+#[test]
+fn new_fails_if_magic_bytes_are_invalid() {
+    let invalid_magic_mnemonic = "ldkfs0000000";
+
+    let path = TempPath::new();
+    path.open()
+        .write_all(invalid_magic_mnemonic.as_bytes())
+        .expect("should write");
+
+    match KeychainStore::<TestKeychain, TxHeight, Transaction>::new(path.open()) {
+        Err(FileError::InvalidMagicBytes(b)) => {
+            assert_eq!(b, invalid_magic_mnemonic.as_bytes())
+        }
+        unexpected => panic!("unexpected result: {:?}", unexpected),
+    };
+}
+
+#[test]
+fn append_changeset_truncates_invalid_bytes() {
+    use bdk_chain::miniscript;
+    use core::str::FromStr;
+    // initial data to write to file (magic bytes + invalid data)
+    let mut data = [255_u8; 2000];
+    data[..MAGIC_BYTES_LEN].copy_from_slice(&MAGIC_BYTES);
+
+    let descriptor = miniscript::Descriptor::from_str("tr([73c5da0a/86'/0'/0']xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ/0/*)#rg247h69").unwrap();
+    let mut tracker = KeychainTracker::<TestKeychain, TxHeight, Transaction>::default();
+    tracker.add_keychain(TestKeychain::External, descriptor);
+    let changeset = KeychainChangeSet {
+        derivation_indices: tracker
+            .txout_index
+            .reveal_to_target(&TestKeychain::External, 21)
+            .1,
+        chain_graph: Default::default(),
+    };
+
+    let path = TempPath::new();
+    path.open().write_all(&data).expect("should write");
+
+    let mut store = KeychainStore::<TestKeychain, TxHeight, Transaction>::new(path.open())
+        .expect("should open");
+    match store.iter_changesets().expect("seek should succeed").next() {
+        Some(Err(IterError::Bincode(_))) => {}
+        unexpected_res => panic!("unexpected result: {:?}", unexpected_res),
+    }
+
+    store.append_changeset(&changeset).expect("should append");
+
+    drop(store);
+
+    let got_bytes = {
+        let mut buf = Vec::new();
+        path.open().read_to_end(&mut buf).expect("should read");
+        buf
+    };
+
+    let expected_bytes = {
+        let mut buf = MAGIC_BYTES.to_vec();
+        bincode::encode_into_std_write(
+            bincode::serde::Compat(&changeset),
+            &mut buf,
+            bincode::config::standard(),
+        )
+        .expect("should encode");
+        buf
+    };
+
+    assert_eq!(got_bytes, expected_bytes);
+}