persistence: use new nonasync crate and its APIs

Cargo.toml

@@ -23,6 +23,7 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 amplify = "4.7.0"
+nonasync = "0.1.0"
 ascii-armor = "0.7.1"
 baid64 = "0.2.2"
 strict_encoding = "2.7.0-rc.1"
@@ -54,6 +55,7 @@ crate-type = ["cdylib", "rlib"] # We need this for WASM
 
 [dependencies]
 amplify = { workspace = true }
+nonasync = { workspace = true }
 ascii-armor = { workspace = true }
 baid64 = { workspace = true }
 strict_encoding = { workspace = true }
@@ -97,4 +99,5 @@ wasm-bindgen-test = "0.3"
 features = ["all"]
 
 [patch.crates-io]
-rgb-core = { git = "https://github.com/RGB-WG/rgb-core", branch = "nonce" }
+nonasync = { git = "https://github.com/rust-amplify/amplify-nonasync" }
+rgb-core = { git = "https://github.com/RGB-WG/rgb-core", branch = "nonce" }

src/persistence/fs.rs

@@ -0,0 +1,90 @@
+// RGB standard library for working with smart contracts on Bitcoin & Lightning
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Written in 2019-2024 by
+//     Dr Maxim Orlovsky <[email protected]>
+//
+// Copyright (C) 2019-2024 LNP/BP Standards Association. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::path::PathBuf;
+
+use amplify::confinement::U32 as U32MAX;
+use nonasync::persistence::{PersistenceError, PersistenceProvider};
+use strict_encoding::{StrictDeserialize, StrictSerialize};
+
+use crate::persistence::{MemIndex, MemStash, MemState};
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct FsBinStore {
+    pub stash: PathBuf,
+    pub state: PathBuf,
+    pub index: PathBuf,
+}
+
+impl FsBinStore {
+    pub fn new(path: PathBuf) -> Self {
+        let mut stash = path.clone();
+        stash.push("stash.dat");
+        let mut state = path.clone();
+        state.push("state.dat");
+        let mut index = path.clone();
+        index.push("index.dat");
+
+        Self {
+            stash,
+            state,
+            index,
+        }
+    }
+}
+impl PersistenceProvider<MemStash> for FsBinStore {
+    fn load(&self) -> Result<MemStash, PersistenceError> {
+        MemStash::strict_deserialize_from_file::<U32MAX>(&self.stash)
+            .map_err(PersistenceError::with)
+    }
+
+    fn store(&self, object: &MemStash) -> Result<(), PersistenceError> {
+        object
+            .strict_serialize_to_file::<U32MAX>(&self.stash)
+            .map_err(PersistenceError::with)
+    }
+}
+
+impl PersistenceProvider<MemState> for FsBinStore {
+    fn load(&self) -> Result<MemState, PersistenceError> {
+        MemState::strict_deserialize_from_file::<U32MAX>(&self.state)
+            .map_err(PersistenceError::with)
+    }
+
+    fn store(&self, object: &MemState) -> Result<(), PersistenceError> {
+        object
+            .strict_serialize_to_file::<U32MAX>(&self.state)
+            .map_err(PersistenceError::with)
+    }
+}
+
+impl PersistenceProvider<MemIndex> for FsBinStore {
+    fn load(&self) -> Result<MemIndex, PersistenceError> {
+        MemIndex::strict_deserialize_from_file::<U32MAX>(&self.index)
+            .map_err(PersistenceError::with)
+    }
+
+    fn store(&self, object: &MemIndex) -> Result<(), PersistenceError> {
+        object
+            .strict_serialize_to_file::<U32MAX>(&self.index)
+            .map_err(PersistenceError::with)
+    }
+}

src/persistence/index.rs

@@ -24,14 +24,15 @@ use std::error::Error;
 use std::fmt::Debug;
 
 use amplify::confinement;
+use nonasync::persistence::Persisting;
 use rgb::{
     Assign, AssignmentType, BundleId, ContractId, ExposedState, Extension, Genesis, GenesisSeal,
     GraphSeal, OpId, Operation, Opout, TransitionBundle, TypedAssigns, XChain, XOutputSeal,
     XWitnessId,
 };
 
 use crate::containers::{BundledWitness, ConsignmentExt, ToWitnessId};
-use crate::persistence::{StoreError, StoreTransaction};
+use crate::persistence::{MemError, StoreTransaction};
 use crate::SecretSeal;
 
 #[derive(Debug, Display, Error, From)]
@@ -84,7 +85,7 @@ impl<P: IndexProvider> From<IndexWriteError<<P as IndexWriteProvider>::Error>> f
     }
 }
 
-impl From<confinement::Error> for IndexWriteError<StoreError> {
+impl From<confinement::Error> for IndexWriteError<MemError> {
     fn from(err: confinement::Error) -> Self { IndexWriteError::Connectivity(err.into()) }
 }
 
@@ -349,7 +350,7 @@ impl<P: IndexProvider> StoreTransaction for Index<P> {
     fn rollback_transaction(&mut self) { self.provider.rollback_transaction() }
 }
 
-pub trait IndexProvider: Debug + IndexReadProvider + IndexWriteProvider {}
+pub trait IndexProvider: Debug + Persisting + IndexReadProvider + IndexWriteProvider {}
 
 pub trait IndexReadProvider {
     type Error: Clone + Eq + Error;