writer: establish wallet model

Author: dr-orlovsky

Cargo.lock

@@ -29,6 +29,8 @@ cyphernet = { version = "0.5.2", features = ["tor", "dns", "ed25519", "p2p-ed255
 microservices = { version = "0.12.0" }
 netservices = { version = "0.12.0-beta.1", features = ["eidolon", "reactor"] }
 crossbeam-channel = "0.5.15"
+native_db = "0.8.2"
+native_model = "0.4.20"
 
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9.34"
@@ -77,6 +79,8 @@ io-reactor.workspace = true
 microservices = { workspace = true, features = ["log"] }
 netservices = { workspace = true, features = ["log"] }
 crossbeam-channel.workspace = true
+native_db.workspace = true
+native_model.workspace = true
 async-channel = { version = "2.3.1", optional = true }
 serde.workspace = true
 log.workspace = true

Cargo.toml

@@ -27,7 +27,7 @@ use bpstd::psbt::Utxo;
 use bpstd::seals::TxoSeal;
 use netservices::Frame;
 use rgb::{ContractState, ContractStateName, WitnessStatus};
-use rgbp::descriptor::RgbDescr;
+use rgbp::descriptors::RgbDescr;
 use sonicapi::{CellAddr, CodexId, ContractId, Opid, StateAtom};
 use strict_types::StrictVal;
 

rpc/src/response.rs

@@ -27,14 +27,20 @@ compile_error!("Either `embedded` or `server` feature must be used");
 #[macro_use]
 extern crate amplify;
 #[macro_use]
+extern crate native_db;
+#[macro_use]
+extern crate native_model;
+#[macro_use]
 extern crate serde;
 
 mod config;
+mod model;
 pub mod services;
 mod workers;
 mod reactors;
 
 pub use config::Config;
+pub use model::{DbHolder, DbUtxos, UtxoId, UtxoModel};
 pub use reactors::*;
 pub use workers::*;
 

src/lib.rs

@@ -0,0 +1,112 @@
+// RGB Node: sovereign smart contracts backend
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Designed in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+// Written in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+//
+// Copyright (C) 2020-2024 LNP/BP Standards Association. All rights reserved.
+// Copyright (C) 2025 RGB Consortium, Switzerland. All rights reserved.
+// Copyright (C) 2020-2025 Dr Maxim Orlovsky. 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::collections::HashSet;
+use std::ops::{Deref, DerefMut};
+use std::sync::LazyLock;
+
+use bpstd::psbt::Utxo;
+use bpstd::{Keychain, NormalIndex, Outpoint, Sats, Terminal, XpubDerivable};
+use native_db::{Builder, Database, Models, db_type};
+use rgbp::descriptors::RgbDescr;
+use rgbp::{MultiHolder, OwnerProvider, UtxoSet};
+
+use crate::model::UtxoModel;
+
+static MODELS: LazyLock<Models> = LazyLock::new(|| {
+    let mut models = Models::new();
+    models.define::<UtxoModel>().unwrap();
+    models
+});
+
+fn db() -> Result<Database<'static>, db_type::Error> { Builder::new().create_in_memory(&MODELS) }
+
+pub struct DbHolder {
+    inner: MultiHolder<XpubDerivable, DbUtxos>,
+    db: Database<'static>,
+}
+
+impl Deref for DbHolder {
+    type Target = MultiHolder<XpubDerivable, DbUtxos>;
+
+    fn deref(&self) -> &Self::Target { &self.inner }
+}
+
+impl DerefMut for DbHolder {
+    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner }
+}
+
+impl DbHolder {
+    pub fn load() -> Result<Self, db_type::Error> {
+        let db = db()?;
+        let inner = MultiHolder::new();
+        // TODO: populate with data
+        Ok(Self { inner, db })
+    }
+}
+
+impl OwnerProvider for DbHolder {
+    type Key = XpubDerivable;
+    type UtxoSet = DbUtxos;
+
+    fn descriptor(&self) -> &RgbDescr<Self::Key> { self.inner.descriptor() }
+
+    fn utxos(&self) -> &Self::UtxoSet { self.inner.utxos() }
+
+    fn descriptor_mut(&mut self) -> &mut RgbDescr<Self::Key> { self.inner.descriptor_mut() }
+
+    fn utxos_mut(&mut self) -> &mut Self::UtxoSet { self.inner.utxos_mut() }
+}
+
+pub struct DbUtxos {
+    db: Database<'static>,
+}
+
+impl DbUtxos {
+    pub fn utxos(&self) -> HashSet<Utxo> { todo!() }
+}
+
+impl UtxoSet for DbUtxos {
+    fn len(&self) -> usize { todo!() }
+
+    fn has(&self, outpoint: Outpoint) -> bool { todo!() }
+
+    fn get(&self, outpoint: Outpoint) -> Option<(Sats, Terminal)> { todo!() }
+
+    fn insert(&mut self, outpoint: Outpoint, value: Sats, terminal: Terminal) { todo!() }
+
+    fn insert_all(&mut self, utxos: impl IntoIterator<Item = Utxo>) { todo!() }
+
+    fn clear(&mut self) { todo!() }
+
+    fn remove(&mut self, outpoint: Outpoint) -> Option<(Sats, Terminal)> { todo!() }
+
+    fn remove_all(&mut self, outpoints: impl IntoIterator<Item = Outpoint>) { todo!() }
+
+    fn outpoints(&self) -> impl Iterator<Item = Outpoint> {
+        todo!();
+        std::iter::empty()
+    }
+
+    fn next_index_noshift(&self, keychain: impl Into<Keychain>) -> NormalIndex { todo!() }
+
+    fn next_index(&mut self, keychain: impl Into<Keychain>, shift: bool) -> NormalIndex { todo!() }
+}

src/model/db.rs

@@ -0,0 +1,26 @@
+// RGB Node: sovereign smart contracts backend
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Designed in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+// Written in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+//
+// Copyright (C) 2020-2024 LNP/BP Standards Association. All rights reserved.
+// Copyright (C) 2025 RGB Consortium, Switzerland. All rights reserved.
+// Copyright (C) 2020-2025 Dr Maxim Orlovsky. 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.
+
+mod utxo;
+mod db;
+
+pub use db::{DbHolder, DbUtxos};
+pub use utxo::{UtxoId, UtxoModel};

src/model/mod.rs

@@ -0,0 +1,52 @@
+// RGB Node: sovereign smart contracts backend
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Designed in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+// Written in 2020-2025 by Dr Maxim Orlovsky <orlovsky@lnp-bp.org>
+//
+// Copyright (C) 2020-2024 LNP/BP Standards Association. All rights reserved.
+// Copyright (C) 2025 RGB Consortium, Switzerland. All rights reserved.
+// Copyright (C) 2020-2025 Dr Maxim Orlovsky. 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 bpstd::{DescrId, Outpoint, Sats, Terminal};
+use native_db::{Key, ToKey};
+use native_model::Model;
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug)]
+#[derive(Serialize, Deserialize)]
+pub struct UtxoId {
+    pub descr: DescrId,
+    pub outpoint: Outpoint,
+}
+
+impl ToKey for UtxoId {
+    fn to_key(&self) -> Key { (self.descr.0, self.outpoint.to_string()).to_key() }
+
+    fn key_names() -> Vec<String> { vec!["utxo_id".to_string()] }
+}
+
+#[derive(PartialEq, Debug)]
+#[derive(Serialize, Deserialize)]
+#[native_model(id = 1, version = 1)]
+#[native_db(primary_key(utxo_id -> UtxoId))]
+pub struct UtxoModel {
+    descr: DescrId,
+    outpoint: Outpoint,
+    terminal: Terminal,
+    value: Sats,
+}
+
+impl UtxoModel {
+    pub fn utxo_id(&self) -> UtxoId { UtxoId { descr: self.descr, outpoint: self.outpoint } }
+}

src/model/utxo.rs

@@ -29,7 +29,7 @@ use crossbeam_channel::Sender;
 use microservices::UService;
 use rgb::popls::bp::seals::TxoSeal;
 use rgb::{CellAddr, ContractId, ContractState, ContractStateName};
-use rgbp::descriptor::RgbDescr;
+use rgbp::descriptors::RgbDescr;
 use rgbrpc::WalletInfo;
 use strict_types::StrictVal;
 

src/services/reader.rs

@@ -19,14 +19,21 @@
 // or implied. See the License for the specific language governing permissions and limitations under
 // the License.
 
+use std::collections::HashSet;
 use std::convert::Infallible;
 use std::ops::ControlFlow;
 
+use bpstd::psbt::PsbtConstructor;
 use bpstd::seals::TxoSeal;
+use bpstd::{Network, XpubDerivable};
 use microservices::{USender, UService};
 use rgb::{Contracts, Pile, Stockpile};
+use rgbp::resolvers::MultiResolver;
+use rgbp::{Owner, OwnerProvider, RgbRuntime};
 
 use super::Request2Reader;
+use crate::services::reader::RoWallet;
+use crate::{DbHolder, DbUtxos};
 
 pub enum Request2Writer {
     Consign(),
@@ -38,7 +45,7 @@ where
     Sp: Stockpile,
     Sp::Pile: Pile<Seal = TxoSeal>,
 {
-    contracts: Contracts<Sp>,
+    runtime: RgbRuntime<Owner<MultiResolver, DbHolder, XpubDerivable, DbUtxos>, Sp>,
     reader: USender<Request2Reader>,
 }
 
@@ -48,18 +55,48 @@ where
     Sp::Stock: Send,
     Sp::Pile: Pile<Seal = TxoSeal> + Send,
 {
-    pub fn new(stockpile: Sp, reader: USender<Request2Reader>) -> Self {
+    pub fn new(network: Network, stockpile: Sp, reader: USender<Request2Reader>) -> Self {
         log::info!(target: Self::NAME, "Loading contracts from persistence");
-        let me = Self { contracts: Contracts::load(stockpile), reader };
+        let contracts = Contracts::load(stockpile);
+
+        // TODO: Use real resolver
+        let resolver = MultiResolver::new_absent().unwrap_or_else(|err| {
+            log::error!(target: Self::NAME, "Unable to connect to the resolver. {err}");
+            panic!("Unable to connect to the resolver due to {err}");
+        });
+
+        log::info!(target: Self::NAME, "Loading wallets from database");
+        let holder = DbHolder::load().unwrap_or_else(|err| {
+            log::error!(target: Self::NAME, "Unable to load database. {err}");
+            panic!("Unable to load database due to {err}");
+        });
+        let owner = Owner::with_components(network, holder, resolver);
+
+        let runtime = RgbRuntime::with_components(owner, contracts);
+        let mut me = Self { runtime, reader };
 
         log::info!(target: Self::NAME, "Contracts loaded successfully, sending state to the reader");
-        for id in me.contracts.contract_ids() {
-            let state = me.contracts.contract_state(id);
+        for id in me.runtime.contracts.contract_ids() {
+            let state = me.runtime.contracts.contract_state(id);
             log::debug!(target: Self::NAME, "Sending contract state for {id}");
             me.reader
                 .send(Request2Reader::UpsertContract(id, state))
                 .unwrap_or_else(|err| panic!("Failed to send state for contract {id}: {err}"));
         }
+
+        log::info!(target: Self::NAME, "Wallets loaded successfully, sending state to the reader");
+        let all_wallets = me.runtime.wallet.wallet_ids().collect::<HashSet<_>>();
+        for id in all_wallets {
+            me.runtime.wallet.switch(id);
+            let descriptor = me.runtime.wallet.descriptor().clone();
+            let utxo = me.runtime.wallet.utxos();
+            let wallet = RoWallet { descriptor, utxos: utxo.utxos() };
+            log::debug!(target: Self::NAME, "Sending wallet state for {id}");
+            me.reader
+                .send(Request2Reader::UpsertWallet(id, wallet))
+                .unwrap_or_else(|err| panic!("Failed to send state for wallet {id}: {err}"));
+        }
+
         me
     }
 }

src/services/writer.rs

@@ -98,7 +98,7 @@ where
         let reader_thread = UThread::new(reader, TIMEOUT);
 
         log::info!("Starting contracts writer thread...");
-        let writer = WriterService::new(stockpile, reader_thread.sender());
+        let writer = WriterService::new(conf.network, stockpile, reader_thread.sender());
         let writer_thread = UThread::new(writer, TIMEOUT);
 
         log::info!("Starting the dispatcher thread...");