Struct Wallet

pub struct Wallet<K, D, L2 = Option<ImpossibleLayer2>>
where
    D: Descriptor<K>,
    L2: Layer2,
{ /* private fields */ }

Implementations

impl<K, D> Wallet<K, D>

where D: Descriptor<K>,

pub fn new_standard(descr: D, network: Network) -> Wallet<K, D>

pub fn with_standard<I>( descr: D, network: Network, indexer: &I, ) -> MayError<Wallet<K, D>, Vec<<I as Indexer>::Error>>

where I: Indexer,

impl<K, D, L2> Wallet<K, D, L2>

where D: Descriptor<K>, L2: Layer2,

pub fn new_layer2( descr: D, l2_descr: <L2 as Layer2>::Descr, layer2: L2, network: Network, ) -> Wallet<K, D, L2>

pub fn with_layer2<I>( descr: D, l2_descr: <L2 as Layer2>::Descr, layer2: L2, network: Network, indexer: &I, ) -> MayError<Wallet<K, D, L2>, Vec<<I as Indexer>::Error>>

where I: Indexer,

pub fn restore( descr: WalletDescr<K, D, <L2 as Layer2>::Descr>, data: WalletData<<L2 as Layer2>::Data>, cache: WalletCache<<L2 as Layer2>::Cache>, layer2: L2, ) -> Wallet<K, D, L2>

pub fn set_name(&mut self, name: String)

pub fn update<B>( &mut self, indexer: &B, ) -> MayError<usize, Vec<<B as Indexer>::Error>>

where B: Indexer,

pub fn to_deriver(&self) -> D

where D: Clone, K: Clone,

pub fn last_derivation_index( &self, keychain: impl Into<Keychain>, ) -> NormalIndex

pub fn next_derivation_index( &mut self, keychain: impl Into<Keychain>, shift: bool, ) -> NormalIndex

pub fn next_address( &mut self, keychain: impl Into<Keychain>, shift: bool, ) -> Address

pub fn balance(&self) -> Sats

pub fn transactions(&self) -> &BTreeMap<Txid, WalletTx>

pub fn coins( &self, ) -> impl Iterator<Item = CoinRow<<<L2 as Layer2>::Cache as Layer2Cache>::Coin>>

pub fn address_coins( &self, ) -> HashMap<DerivedAddr, Vec<CoinRow<<<L2 as Layer2>::Cache as Layer2Cache>::Coin>>>

pub fn address_balance(&self) -> impl Iterator<Item = WalletAddr>

pub fn history( &self, ) -> impl Iterator<Item = TxRow<<<L2 as Layer2>::Cache as Layer2Cache>::Tx>>

pub fn utxo(&self, outpoint: Outpoint) -> Result<WalletUtxo, NonWalletItem>

pub fn all_utxos(&self) -> impl Iterator<Item = WalletUtxo>

pub fn coinselect<'a>( &'a self, up_to: Sats, selector: impl Fn(&WalletUtxo) -> bool + 'a, ) -> impl Iterator<Item = Outpoint> + 'a

impl<K, D, L2> Wallet<K, D, L2>

where D: Descriptor<K> + for<'de> Serialize + for<'de> Deserialize<'de>, L2: Layer2 + for<'de> Serialize + for<'de> Deserialize<'de>, WalletDescr<K, D>: for<'de> Serialize + for<'de> Deserialize<'de>, <L2 as Layer2>::Descr: for<'de> Serialize + for<'de> Deserialize<'de>, <L2 as Layer2>::Data: for<'de> Serialize + for<'de> Deserialize<'de>, <L2 as Layer2>::Cache: for<'de> Serialize + for<'de> Deserialize<'de>,

pub fn load( path: &Path, ) -> Result<(Wallet<K, D, L2>, Vec<Warning>), LoadError<<L2 as Layer2>::LoadError>>

pub fn store( &self, path: &Path, ) -> Result<(), StoreError<<L2 as Layer2>::StoreError>>

impl<K, D, L2> Wallet<K, D, L2>

where D: Descriptor<K>, L2: Layer2,

pub fn construct_psbt<'a, 'b>( &mut self, coins: impl IntoIterator<Item = Outpoint>, beneficiaries: impl IntoIterator<Item = &'b Beneficiary>, params: TxParams, ) -> Result<(Psbt, PsbtMeta), ConstructionError>

Methods from Deref<Target = WalletDescr<K, D, <L2 as Layer2>::Descr>>

pub fn generator(&self) -> &D

Method borrowing WalletDescr::generator field.

pub fn network(&self) -> Network

Method returning copy of WalletDescr::network field.

pub fn layer2(&self) -> &L2

Method borrowing WalletDescr::layer2 field.

pub fn _phantom(&self) -> &PhantomData<K>

Method borrowing WalletDescr::_phantom field.

pub fn addresses(&self, keychain: impl Into<Keychain>) -> AddrIter<'_, K, D>

Trait Implementations

impl<K, D, L2> Clone for Wallet<K, D, L2>

where K: Clone, D: Clone + Descriptor<K>, L2: Clone + Layer2, <L2 as Layer2>::Descr: Clone, <L2 as Layer2>::Data: Clone, <L2 as Layer2>::Cache: Clone,

fn clone(&self) -> Wallet<K, D, L2>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, D, L2> Debug for Wallet<K, D, L2>

where K: Debug, D: Debug + Descriptor<K>, L2: Debug + Layer2, <L2 as Layer2>::Descr: Debug, <L2 as Layer2>::Data: Debug, <L2 as Layer2>::Cache: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<K, D, L2> Deref for Wallet<K, D, L2>

where D: Descriptor<K>, L2: Layer2,

type Target = WalletDescr<K, D, <L2 as Layer2>::Descr>

The resulting type after dereferencing.

fn deref(&self) -> &<Wallet<K, D, L2> as Deref>::Target

Dereferences the value.

impl<K, D, L2> DerefMut for Wallet<K, D, L2>

where D: Descriptor<K>, L2: Layer2,

fn deref_mut(&mut self) -> &mut <Wallet<K, D, L2> as Deref>::Target

Mutably dereferences the value.

impl<K, D, L2> PartialEq for Wallet<K, D, L2>

where K: PartialEq, D: PartialEq + Descriptor<K>, L2: PartialEq + Layer2, <L2 as Layer2>::Descr: PartialEq, <L2 as Layer2>::Data: PartialEq, <L2 as Layer2>::Cache: PartialEq,

fn eq(&self, other: &Wallet<K, D, L2>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, D, L2> Eq for Wallet<K, D, L2>

where K: Eq, D: Eq + Descriptor<K>, L2: Eq + Layer2, <L2 as Layer2>::Descr: Eq, <L2 as Layer2>::Data: Eq, <L2 as Layer2>::Cache: Eq,

impl<K, D, L2> StructuralPartialEq for Wallet<K, D, L2>

where D: Descriptor<K>, L2: Layer2,