chore: update to new RGB std APIs

Cargo.toml

@@ -74,7 +74,6 @@ descriptors = { workspace = true }
 bp-wallet = { workspace = true }
 rgb-std = { workspace = true }
 rgb-psbt = { workspace = true }
-rgb-interfaces = { workspace = true }
 indexmap = { workspace = true }
 chrono = { workspace = true }
 serde_crate = { workspace = true, optional = true }
@@ -105,4 +104,4 @@ bp-wallet = { git = "https://github.com/BP-WG/bp-wallet", branch = "master" }
 rgb-core = { git = "https://github.com/RGB-WG/rgb-core", branch = "mining" }
 rgb-invoice = { git = "https://github.com/RGB-WG/rgb-std", branch = "mining" }
 rgb-std = { git = "https://github.com/RGB-WG/rgb-std", branch = "mining" }
-rgb-interfaces = { git = "https://github.com/RGB-WG/rgb-interfaces.git", branch = "master" }
+rgb-interfaces = { git = "https://github.com/RGB-WG/rgb-interfaces.git", branch = "mining" }

cli/src/command.rs

@@ -46,6 +46,7 @@ use rgb::{
     RgbKeychain, RgbWallet, StateType, TransferParams, WalletError, WalletProvider, XChain,
     XOutpoint, XOutputSeal,
 };
+use rgbstd::containers::ConsignmentExt;
 use serde_crate::{Deserialize, Serialize};
 use strict_types::encoding::{FieldName, TypeName};
 use strict_types::StrictVal;
@@ -345,23 +346,23 @@ impl Exec for RgbArgs {
                 standard: Some(IfaceStandard::Rgb20),
             } => {
                 let stock = self.rgb_stock()?;
-                for info in stock.contracts_by::<Rgb20>()? {
+                for info in stock.contracts_by::<Rgb20<_>>()? {
                     print!("{info}");
                 }
             }
             Command::Contracts {
                 standard: Some(IfaceStandard::Rgb21),
             } => {
                 let stock = self.rgb_stock()?;
-                for info in stock.contracts_by::<Rgb21>()? {
+                for info in stock.contracts_by::<Rgb21<_>>()? {
                     print!("{info}");
                 }
             }
             Command::Contracts {
                 standard: Some(IfaceStandard::Rgb25),
             } => {
                 let stock = self.rgb_stock()?;
-                for info in stock.contracts_by::<Rgb25>()? {
+                for info in stock.contracts_by::<Rgb25<_>>()? {
                     print!("{info}");
                 }
             }
@@ -488,7 +489,8 @@ impl Exec for RgbArgs {
 
                 let contract = stock.contract_iface(*contract_id, tn!(iface.to_owned()))?;
 
-                let filter = match self.rgb_wallet_from_stock(&config, stock) {
+                // TODO: Remove clone
+                let filter = match self.rgb_wallet_from_stock(&config, stock.clone()) {
                     Ok(wallet) if *all => Filter::WalletAll(wallet),
                     Ok(wallet) => Filter::Wallet(wallet),
                     Err(_) => {
@@ -1011,10 +1013,10 @@ impl Exec for RgbArgs {
                 // TODO: Add sigs debugging
 
                 // State
-                for (id, history) in stock.as_state_provider().debug_history() {
+                for (id, state) in stock.as_state_provider().debug_contracts() {
                     fs::write(
                         format!("{root_dir}/state/{id:-}.yaml"),
-                        serde_yaml::to_string(history)?,
+                        serde_yaml::to_string(state)?,
                     )?;
                 }
 

src/indexers/any.rs

@@ -26,9 +26,10 @@ use std::collections::HashMap;
 use bp::Tx;
 use bpstd::Network;
 use rgbstd::containers::Consignment;
-use rgbstd::resolvers::ResolveHeight;
+use rgbstd::resolvers::ResolveWitnessAnchor;
 use rgbstd::validation::{ResolveWitness, WitnessResolverError};
-use rgbstd::{WitnessAnchor, XWitnessId, XWitnessTx};
+use rgbstd::vm::WitnessAnchor;
+use rgbstd::{XWitnessId, XWitnessTx};
 
 use crate::{Txid, WitnessOrd, XChain};
 
@@ -96,7 +97,7 @@ impl AnyResolver {
             consignment
                 .bundles
                 .iter()
-                .filter_map(|bw| bw.pub_witness.maybe_map_ref(|w| w.tx.clone()))
+                .filter_map(|bw| bw.pub_witness.maybe_map_ref(|w| w.tx().cloned()))
                 .filter_map(|tx| match tx {
                     XChain::Bitcoin(tx) => Some(tx),
                     XChain::Liquid(_) | XChain::Other(_) => None,
@@ -106,8 +107,8 @@ impl AnyResolver {
     }
 }
 
-impl ResolveHeight for AnyResolver {
-    fn resolve_height(&mut self, witness_id: XWitnessId) -> Result<WitnessAnchor, String> {
+impl ResolveWitnessAnchor for AnyResolver {
+    fn resolve_witness_anchor(&mut self, witness_id: XWitnessId) -> Result<WitnessAnchor, String> {
         let XWitnessId::Bitcoin(txid) = witness_id else {
             return Err(format!("{} is not supported as layer 1 network", witness_id.layer1()));
         };

src/indexers/electrum_blocking.rs

@@ -26,7 +26,8 @@ use std::iter;
 use bp::ConsensusDecode;
 use bpstd::{Network, Tx, Txid};
 use electrum::{Client, ElectrumApi, Error, Param};
-use rgbstd::{WitnessAnchor, WitnessOrd, WitnessPos, XWitnessId};
+use rgbstd::vm::WitnessAnchor;
+use rgbstd::{WitnessOrd, WitnessPos, XWitnessId};
 
 use super::RgbResolver;
 

src/indexers/esplora_blocking.rs

@@ -22,7 +22,8 @@
 use bp::Tx;
 use bpstd::{Network, Txid};
 use esplora::{BlockingClient, Error};
-use rgbstd::{WitnessAnchor, WitnessOrd, WitnessPos};
+use rgbstd::vm::WitnessAnchor;
+use rgbstd::{WitnessOrd, WitnessPos};
 
 use super::RgbResolver;
 use crate::XWitnessId;

src/indexers/mempool_blocking.rs

@@ -22,7 +22,7 @@
 use bp::Tx;
 use bpstd::{Network, Txid};
 use esplora::{BlockingClient, Config, Error};
-use rgbstd::WitnessAnchor;
+use rgbstd::vm::WitnessAnchor;
 
 use super::RgbResolver;
 

src/pay.rs

@@ -32,14 +32,18 @@ use psrgbt::{
     TxParams,
 };
 use rgbstd::containers::Transfer;
-use rgbstd::interface::{OutpointFilter, WitnessFilter};
+use rgbstd::interface::OutpointFilter;
 use rgbstd::invoice::{Amount, Beneficiary, InvoiceState, RgbInvoice};
 use rgbstd::persistence::{IndexProvider, StashProvider, StateProvider, Stock};
-use rgbstd::{ContractId, DataState, XChain, XOutpoint};
+use rgbstd::resolvers::ResolveWitnessAnchor;
+use rgbstd::{ContractId, DataState, WitnessOrd, XChain, XOutpoint};
 
 use crate::invoice::NonFungible;
+use crate::vm::WitnessAnchor;
 use crate::wrapper::WalletWrapper;
-use crate::{CompletionError, CompositionError, DescriptorRgb, PayError, RgbKeychain, Txid};
+use crate::{
+    CompletionError, CompositionError, DescriptorRgb, PayError, RgbKeychain, Txid, XWitnessId,
+};
 
 #[derive(Clone, PartialEq, Debug)]
 pub struct TransferParams {
@@ -95,7 +99,7 @@ where W::Descr: DescriptorRgb<K>
 pub trait WalletProvider<K>: PsbtConstructor
 where Self::Descr: DescriptorRgb<K>
 {
-    type Filter<'a>: Copy + WitnessFilter + OutpointFilter
+    type Filter<'a>: Copy + OutpointFilter
     where Self: 'a;
     fn filter(&self) -> Self::Filter<'_>;
     fn descriptor_mut<R>(&mut self, f: impl FnOnce(&mut WalletDescr<K, Self::Descr>) -> R) -> R;
@@ -127,9 +131,6 @@ where Self::Descr: DescriptorRgb<K>
 
         let iface_name = invoice.iface.clone().ok_or(CompositionError::NoIface)?;
         let iface = stock.iface(iface_name.clone()).map_err(|e| e.to_string())?;
-        let contract = stock
-            .contract_iface(contract_id, iface_name)
-            .map_err(|e| e.to_string())?;
         let operation = invoice
             .operation
             .as_ref()
@@ -148,14 +149,17 @@ where Self::Descr: DescriptorRgb<K>
             .cloned()
             .ok_or(CompositionError::NoAssignment)?;
 
+        let filter = ContractOutpointsFilter {
+            contract_id,
+            stock,
+            wallet: self,
+            _phantom: PhantomData,
+        };
+        let contract = stock
+            .contract_iface(contract_id, iface_name)
+            .map_err(|e| e.to_string())?;
         let prev_outputs = match invoice.owned_state {
             InvoiceState::Amount(amount) => {
-                let filter = ContractOutpointsFilter {
-                    contract_id,
-                    stock,
-                    wallet: self,
-                    _phantom: PhantomData,
-                };
                 let state: BTreeMap<_, Vec<Amount>> = contract
                     .fungible(assignment_name, &filter)?
                     .fold(bmap![], |mut set, a| {
@@ -183,17 +187,9 @@ where Self::Descr: DescriptorRgb<K>
                     .collect::<BTreeSet<_>>()
             }
             InvoiceState::Data(NonFungible::RGB21(allocation)) => {
-                let filter = ContractOutpointsFilter {
-                    contract_id,
-                    stock,
-                    wallet: self,
-                    _phantom: PhantomData,
-                };
-                let state = contract.data(assignment_name, &filter)?.collect::<Vec<_>>();
-
                 let data_state = DataState::from(allocation);
-                state
-                    .into_iter()
+                contract
+                    .data(assignment_name, &filter)?
                     .filter(|x| x.state == data_state)
                     .map(|x| x.seal)
                     .collect::<BTreeSet<_>>()
@@ -312,8 +308,23 @@ where Self::Descr: DescriptorRgb<K>
             Beneficiary::BlindedSeal(seal) => (vec![XChain::Bitcoin(seal)], vec![]),
         };
 
+        struct FasciaResolver {
+            priority: u32,
+        }
+        impl ResolveWitnessAnchor for FasciaResolver {
+            fn resolve_witness_anchor(
+                &mut self,
+                witness_id: XWitnessId,
+            ) -> Result<WitnessAnchor, String> {
+                Ok(WitnessAnchor {
+                    witness_ord: WitnessOrd::offchain(self.priority),
+                    witness_id,
+                })
+            }
+        }
+
         stock
-            .consume_fascia(fascia, priority)
+            .consume_fascia(fascia, FasciaResolver { priority })
             .map_err(|e| e.to_string())?;
         let transfer = stock
             .transfer(contract_id, beneficiary2, beneficiary1)

src/wallet.rs

@@ -131,7 +131,7 @@ where W::Descr: DescriptorRgb<K>
             .contract_iface(contract_id, iref)
             .map_err(|e| e.to_string())?;
         Ok(contract
-            .fungible_ops::<AmountChange>(state_name, wallet.filter(), wallet.filter())
+            .fungible_ops::<AmountChange>(state_name, wallet.filter())
             .map_err(|e| e.to_string())?)
     }
 

src/wrapper.rs

@@ -20,9 +20,9 @@
 // limitations under the License.
 
 use bpwallet::{Save, Wallet};
-use rgbstd::interface::{OutpointFilter, WitnessFilter};
+use rgbstd::interface::OutpointFilter;
 
-use crate::{AssignmentWitness, DescriptorRgb, WalletProvider, XChain, XOutpoint, XWitnessId};
+use crate::{DescriptorRgb, WalletProvider, XChain, XOutpoint};
 
 pub struct WalletWrapper<'a, K, D: DescriptorRgb<K>>(pub &'a Wallet<K, D>)
 where Wallet<K, D>: Save;
@@ -44,14 +44,3 @@ where Wallet<K, D>: Save
             .any(|outpoint| XChain::Bitcoin(outpoint) == *output)
     }
 }
-
-impl<'a, K, D: DescriptorRgb<K>> WitnessFilter for WalletWrapper<'a, K, D>
-where Wallet<K, D>: Save
-{
-    fn include_witness(&self, witness: impl Into<AssignmentWitness>) -> bool {
-        let witness = witness.into();
-        self.0
-            .txids()
-            .any(|txid| AssignmentWitness::Present(XWitnessId::Bitcoin(txid)) == witness)
-    }
-}