Merge pull request #325 from RGB-WG/node

New APIs required by RGB Node

Author: dr-orlovsky

src/contracts.rs

@@ -39,17 +39,77 @@ use rgb::RgbSeal;
 use strict_encoding::{
     ReadRaw, StrictDecode, StrictDumb, StrictEncode, StrictReader, StrictWriter, WriteRaw,
 };
+use strict_types::StrictVal;
 
 use crate::{
     parse_consignment, Articles, Consensus, Consignment, ConsumeError, Contract, ContractRef,
-    ContractState, CreateParams, Identity, Issuer, Operation, Pile, SigBlob, Stockpile,
-    WitnessStatus,
+    ContractState, CreateParams, Identity, ImmutableState, Issuer, Operation, OwnedState, Pile,
+    SigBlob, StateName, Stockpile, WitnessStatus,
 };
 
 pub const CONSIGN_VERSION: u16 = 0;
 #[cfg(feature = "binfile")]
 pub use _fs::CONSIGN_MAGIC_NUMBER;
 
+#[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Display)]
+#[display("{contract_id}/{state_name}")]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(rename_all = "camelCase"))]
+pub struct ContractStateName {
+    pub contract_id: ContractId,
+    pub state_name: StateName,
+}
+
+impl ContractStateName {
+    pub fn new(contract_id: ContractId, state_name: StateName) -> Self {
+        ContractStateName { contract_id, state_name }
+    }
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+#[cfg_attr(
+    feature = "serde",
+    derive(Serialize, Deserialize),
+    serde(
+        rename_all = "camelCase",
+        bound = "Seal: serde::Serialize + for<'d> serde::Deserialize<'d>"
+    )
+)]
+pub struct WalletState<Seal> {
+    pub immutable: BTreeMap<ContractStateName, Vec<ImmutableState>>,
+    pub owned: BTreeMap<ContractStateName, Vec<OwnedState<Seal>>>,
+    pub aggregated: BTreeMap<ContractStateName, StrictVal>,
+}
+
+impl<Seal> Default for WalletState<Seal> {
+    fn default() -> Self { Self { immutable: bmap! {}, owned: bmap! {}, aggregated: bmap! {} } }
+}
+
+impl<Seal> WalletState<Seal> {
+    pub fn from_contracts_state(
+        contracts: impl IntoIterator<Item = (ContractId, ContractState<Seal>)>,
+    ) -> Self {
+        let mut wallet_state = WalletState::default();
+        for (contract_id, contract_state) in contracts {
+            for (state_name, state) in contract_state.immutable {
+                wallet_state
+                    .immutable
+                    .insert(ContractStateName::new(contract_id, state_name), state);
+            }
+            for (state_name, state) in contract_state.owned {
+                wallet_state
+                    .owned
+                    .insert(ContractStateName::new(contract_id, state_name), state);
+            }
+            for (state_name, state) in contract_state.aggregated {
+                wallet_state
+                    .aggregated
+                    .insert(ContractStateName::new(contract_id, state_name), state);
+            }
+        }
+        wallet_state
+    }
+}
+
 /// Collection of RGB smart contracts and contract issuers, which can be cached in memory.
 ///
 /// # Generics

src/lib.rs

@@ -77,7 +77,9 @@ pub use contract::{
 };
 #[cfg(feature = "binfile")]
 pub use contracts::CONSIGN_MAGIC_NUMBER;
-pub use contracts::{Contracts, IssuerError, SyncError, CONSIGN_VERSION};
+pub use contracts::{
+    ContractStateName, Contracts, IssuerError, SyncError, WalletState, CONSIGN_VERSION,
+};
 pub use hypersonic::*;
 pub use pile::{OpRels, Pile, Witness, WitnessStatus};
 pub use rgb::*;

src/popls/bp.rs

@@ -28,6 +28,7 @@
 use alloc::collections::btree_map::Entry;
 use alloc::collections::{btree_set, BTreeMap, BTreeSet};
 use alloc::vec;
+use core::mem;
 use std::collections::HashMap;
 
 use amplify::confinement::{
@@ -55,7 +56,8 @@ use strict_types::StrictVal;
 use crate::contracts::SyncError;
 use crate::{
     Assignment, CodexId, Consensus, ConsumeError, Contract, ContractState, Contracts, CreateParams,
-    EitherSeal, Identity, Issuer, IssuerError, OwnedState, Pile, SigBlob, Stockpile, WitnessStatus,
+    EitherSeal, Identity, Issuer, IssuerError, OwnedState, Pile, SigBlob, Stockpile, WalletState,
+    WitnessStatus,
 };
 
 /// Trait abstracting a specific implementation of a bitcoin wallet.
@@ -438,6 +440,8 @@ where
 
     pub fn into_components(self) -> (W, Contracts<Sp, S, C>) { (self.wallet, self.contracts) }
 
+    pub fn switch_wallet(&mut self, new: W) -> W { mem::replace(&mut self.wallet, new) }
+
     pub fn issue(
         &mut self,
         params: CreateParams<Outpoint>,
@@ -463,7 +467,15 @@ where
         WitnessOut::new(address.payload, nonce)
     }
 
-    pub fn state_own(&self, contract_id: ContractId) -> ContractState<Outpoint> {
+    pub fn wallet_state(&self) -> WalletState<TxoSeal> {
+        let iter = self
+            .contracts
+            .contract_ids()
+            .map(|id| (id, self.contracts.contract_state(id)));
+        WalletState::from_contracts_state(iter)
+    }
+
+    pub fn wallet_contract_state(&self, contract_id: ContractId) -> ContractState<Outpoint> {
         self.contracts
             .contract_state(contract_id)
             .clone()
@@ -478,7 +490,10 @@ where
             )
     }
 
-    pub fn state_all(&self, contract_id: ContractId) -> ContractState<<Sp::Pile as Pile>::Seal> {
+    pub fn contract_state_full(
+        &self,
+        contract_id: ContractId,
+    ) -> ContractState<<Sp::Pile as Pile>::Seal> {
         self.contracts.contract_state(contract_id)
     }
 
@@ -512,7 +527,7 @@ where
         let value = invoice.data.as_ref().ok_or(FulfillError::ValueMissed)?;
 
         // Do coinselection
-        let state = self.state_own(contract_id);
+        let state = self.wallet_contract_state(contract_id);
         let state = state
             .owned
             .get(&state_name)