bark

Struct Wallet

Source 
pub struct Wallet {
    pub chain: Arc<ChainSource>,
    pub exit: RwLock<Exit>,
    pub movements: Arc<MovementManager>,
    /* private fields */
}
Expand description

The central entry point for using this library as an Ark wallet.

Overview

Key capabilities

  • Address management:
    • derive and peek deterministic Ark addresses and their indices
  • Funds lifecycle:
    • board funds from an external onchain wallet onto the Ark
    • send out-of-round Ark payments (arkoor)
    • offboard funds to onchain addresses
    • manage HTLCs and Lightning receives/sends
  • VTXO management:
    • query spendable and pending VTXOs
    • refresh expiring or risky VTXOs
    • compute balance broken down by spendable/pending states
  • Synchronization and maintenance:
    • sync against the Ark server and the onchain source
    • reconcile pending rounds, exits, and offchain state
    • periodic maintenance helpers (e.g., auto-register boards, refresh policies)

Construction and persistence

Example

let network = Network::Signet;
let mnemonic = Mnemonic::generate(12)?;
let cfg = Config {
  server_address: String::from("https://ark.signet.2nd.dev"),
  esplora_address: Some(String::from("https://esplora.signet.2nd.dev")),
  ..Default::default()
};

// You can either use the included SQLite implementation or create your own.
let persister = SqliteClient::open(db_path).await?;
let db: Arc<dyn BarkPersister> = Arc::new(persister);

// Load or create an onchain wallet if needed
let onchain_wallet = OnchainWallet::load_or_create(network, mnemonic.to_seed(""), db.clone()).await?;

// Create or open the Ark wallet
let mut wallet = Wallet::create_with_onchain(
	&mnemonic,
	network,
	cfg.clone(),
	db,
	&onchain_wallet,
	false,
).await?;
// let mut wallet = Wallet::create(&mnemonic, network, cfg.clone(), db.clone(), false).await?;
// let mut wallet = Wallet::open(&mnemonic, db.clone(), cfg.clone()).await?;
// let mut wallet = Wallet::open_with_onchain(
//    &mnemonic, network, cfg.clone(), db.clone(), &onchain_wallet
// ).await?;

// There are two main ways to update the wallet, the primary is to use one of the maintenance
// commands which will sync everything, refresh VTXOs and reconcile pending lightning payments.
wallet.maintenance().await?;
wallet.maintenance_with_onchain(&mut onchain_wallet).await?;

// Alternatively, you can use the fine-grained sync commands to sync individual parts of the
// wallet state and use `maintenance_refresh` where necessary to refresh VTXOs.
wallet.sync().await?;
wallet.sync_pending_lightning_send_vtxos().await?;
wallet.register_all_confirmed_boards(&mut onchain_wallet).await?;
wallet.sync_exits(&mut onchain_wallet).await?;
wallet.maintenance_refresh().await?;

// Generate a new Ark address to receive funds via arkoor
let addr = wallet.new_address().await?;

// Query balance and VTXOs
let balance = wallet.balance()?;
let vtxos = wallet.vtxos()?;

// Progress any unilateral exits, make sure to sync first
wallet.exit.progress_exit(&mut onchain_wallet, None).await?;

Fields§

§chain: Arc<ChainSource>

The chain source the wallet is connected to

§exit: RwLock<Exit>

Exit subsystem handling unilateral exits and on-chain reconciliation outside Ark rounds.

§movements: Arc<MovementManager>

Allows easy creation of and management of wallet fund movements.

Implementations§

Source§

impl Wallet

Source

pub async fn join_next_round( &self, participation: RoundParticipation, movement_kind: Option<RoundMovement>, ) -> Result<StoredRoundState>

Start a new round participation

This function will store the state in the db and mark the VTXOs as locked.

Source

pub async fn join_non_interactive_round( &self, participation: RoundParticipation, movement_kind: Option<RoundMovement>, ) -> Result<StoredRoundState>

Source

pub async fn pending_round_states(&self) -> Result<Vec<StoredRoundState>>

Get all pending round states

Source

pub async fn sync_pending_rounds(&self) -> Result<()>

Sync pending rounds that have finished but are waiting for confirmations

Source

pub async fn progress_pending_rounds( &self, last_round_event: Option<&RoundEvent>, ) -> Result<()>

Try to make incremental progress on all pending round states

If the last_round_event argument is not provided, it will be fetched from the server.

Source

pub async fn subscribe_round_events( &self, ) -> Result<impl Stream<Item = Result<RoundEvent>> + Unpin>

Source

pub async fn participate_ongoing_rounds(&self) -> Result<()>

A blocking call that will try to perform a full round participation for all ongoing rounds

Returns only once a round has happened on the server.

Source

pub async fn cancel_all_pending_rounds(&self) -> Result<()>

Will cancel all pending rounds that can safely be canceled

All rounds that have not started yet can safely be canceled, as well as rounds where we have not yet signed any forfeit txs.

Source

pub async fn cancel_pending_round(&self, id: RoundStateId) -> Result<()>

Try to cancel the given round

Source§

impl Wallet

Source

pub async fn lock_vtxos( &self, vtxos: impl IntoIterator<Item = impl VtxoRef>, movement_id: Option<MovementId>, ) -> Result<()>

Attempts to lock VTXOs with the given VtxoId values. This will only work if the current VtxoState is contained by VtxoStateKind::UNSPENT_STATES.

§Errors
  • If the VTXO is not in a lockable VtxoState.
  • If the VTXO doesn’t exist.
  • If a database error occurs.
Source

pub async fn mark_vtxos_as_spent( &self, vtxos: impl IntoIterator<Item = impl VtxoRef>, ) -> Result<()>

Marks VTXOs as VtxoState::Spent.

This operation is idempotent: VTXOs already in VtxoState::Spent will remain spent (a redundant state entry may be added to history).

§Errors
  • If the VTXO doesn’t exist.
  • If a database error occurs.
Source

pub async fn set_vtxo_states( &self, vtxos: impl IntoIterator<Item = impl VtxoRef>, state: &VtxoState, allowed_states: &[VtxoStateKind], ) -> Result<()>

Updates the state set the VtxoState of VTXOs corresponding to each given VtxoId while validating if the transition is allowed based on the current state and allowed transitions.

§Parameters
  • vtxos: The VtxoId of each Vtxo to update.
  • state: A reference to the new VtxoState that the VTXOs should be transitioned to.
  • allowed_states: A slice of VtxoStateKind representing the permissible current states from which the VTXOs are allowed to transition to the given state.
§Errors
  • The database operation to update the states fails.
  • The state transition is invalid or does not match the allowed transitions.
Source

pub async fn store_locked_vtxos<'a>( &self, vtxos: impl IntoIterator<Item = &'a Vtxo>, movement_id: Option<MovementId>, ) -> Result<()>

Stores the given collection of VTXOs in the wallet with an initial state of VtxoState::Locked.

§Parameters
  • vtxos: The VTXOs to store in the wallet.
Source

pub async fn store_spendable_vtxos<'a>( &self, vtxos: impl IntoIterator<Item = &'a Vtxo>, ) -> Result<()>

Stores the given collection of VTXOs in the wallet with an initial state of VtxoState::Spendable.

§Parameters
  • vtxos: The VTXOs to store in the wallet.
Source

pub async fn store_spent_vtxos<'a>( &self, vtxos: impl IntoIterator<Item = &'a Vtxo>, ) -> Result<()>

Stores the given collection of VTXOs in the wallet with an initial state of VtxoState::Spent.

§Parameters
  • vtxos: The VTXOs to store in the wallet.
Source

pub async fn store_vtxos<'a>( &self, vtxos: impl IntoIterator<Item = &'a Vtxo>, state: &VtxoState, ) -> Result<()>

Stores the given collection of VTXOs in the wallet with the given initial state.

§Parameters
  • vtxos: The VTXOs to store in the wallet.
  • state: The initial state of the VTXOs.
Source

pub async fn unlock_vtxos( &self, vtxos: impl IntoIterator<Item = impl VtxoRef>, ) -> Result<()>

Attempts to unlock VTXOs with the given VtxoId values. This will only work if the current VtxoState is VtxoStateKind::Locked.

§Errors
  • If the VTXO is not currently locked.
  • If the VTXO doesn’t exist.
  • If a database error occurs.
Source§

impl Wallet

Source

pub async fn validate_arkoor_address(&self, address: &Address) -> Result<()>

Validate if we can send arkoor payments to the given ark::Address, for example an error will be returned if the given ark::Address belongs to a different server (see ark::address::ArkId).

Source

pub async fn send_arkoor_payment( &self, destination: &Address, amount: Amount, ) -> Result<Vec<Vtxo>>

Makes an out-of-round payment to the given ark::Address. This does not require waiting for a round, so it should be relatively instantaneous.

If the Wallet doesn’t contain a VTXO larger than the given Amount, multiple payments will be chained together, resulting in the recipient receiving multiple VTXOs.

Note that a change Vtxo may be created as a result of this call. With each payment these will become more uneconomical to unilaterally exit, so you should eventually refresh them with Wallet::refresh_vtxos or periodically call Wallet::maintenance_refresh.

Source§

impl Wallet

Source

pub async fn check_lightning_payment( &self, payment_hash: PaymentHash, wait: bool, ) -> Result<Option<Preimage>>

Checks the status of a lightning payment associated with a set of VTXOs, processes the payment result and optionally takes appropriate actions based on the payment outcome.

§Arguments
  • payment_hash - The PaymentHash identifying the lightning payment.
  • wait - If true, asks the server to wait for payment completion (may block longer).
§Returns

Returns Ok(Some(Preimage)) if the payment is successfully completed and a preimage is received. Returns Ok(None) for payments still pending, failed payments or if necessary revocation or exit processing occurs. Returns an Err if an error occurs during the process.

§Behavior
  • Validates that all HTLC VTXOs share the same invoice, amount and policy.
  • Sends a request to the Ark server to check the payment status.
  • Depending on the payment status:
    • Failed: Revokes the associated VTXOs.
    • Pending: Checks if the HTLC has expired based on the tip height. If expired, revokes the VTXOs.
    • Complete: Extracts the payment preimage, logs the payment, registers movement in the database and returns the preimage.
Source

pub async fn pay_lightning_invoice<T>( &self, invoice: T, user_amount: Option<Amount>, ) -> Result<LightningSend>
where T: TryInto<Invoice>, T::Error: Error + Display + Send + Sync + 'static,

Pays a Lightning Invoice using Ark VTXOs. This is also an out-of-round payment so the same Wallet::send_arkoor_payment rules apply.

§Returns

Returns the Invoice for which payment was initiated.

Source

pub async fn pay_lightning_address( &self, addr: &LightningAddress, amount: Amount, comment: Option<impl AsRef<str>>, ) -> Result<LightningSend>

Same as Wallet::pay_lightning_invoice but instead it pays a LightningAddress.

Source

pub async fn pay_lightning_offer( &self, offer: Offer, user_amount: Option<Amount>, ) -> Result<LightningSend>

Attempts to pay the given BOLT12 Offer using offchain funds.

Source

pub async fn make_lightning_payment( &self, invoice: &Invoice, original_payment_method: PaymentMethod, user_amount: Option<Amount>, ) -> Result<LightningSend>

Makes a payment using the Lightning Network. This is a low-level primitive to allow for more fine-grained control over the payment process. The primary purpose of using this method is to support PaymentMethod::Custom for other payment use cases such as LNURL-Pay.

It’s recommended to use the following higher-level functions where suitable:

§Parameters
  • invoice: A reference to the BOLT11/BOLT12 invoice to be paid.
  • original_payment_method: The payment method that the given invoice was originally derived from (e.g., BOLT11, an offer, lightning address). This will appear in the stored Movement.
  • user_amount: An optional custom amount to override the amount specified in the invoice. If not provided, the invoice’s amount is used.
§Returns

Returns a LightningSend representing the successful payment. If an error occurs during the process, an anyhow::Error is returned.

§Errors

This function can return an error for the following reasons:

  • If the given payment method is not either an officially supported lightning payment method or PaymentMethod::Custom.
  • The invoice belongs to a different network than the one configured in the server’s properties.
  • The invoice has already been paid (the payment hash exists in the database).
  • The invoice contains an invalid or tampered signature.
  • The amount to be sent is smaller than the dust limit (P2TR_DUST).
  • The wallet doesn’t have enough funds to cover the payment.
  • Validation, signing, server or network issues occur.
§Notes
  • A movement won’t be recorded until we receive an intermediary HTLC VTXO.
  • This is effectively an arkoor payment with an additional HTLC conversion step, so the same Wallet::send_arkoor_payment rules apply.
Source§

impl Wallet

Source

pub async fn bolt11_invoice(&self, amount: Amount) -> Result<Bolt11Invoice>

Create, store and return a Bolt11Invoice for offchain boarding

Source

pub async fn lightning_receive_status( &self, payment: impl Into<PaymentHash>, ) -> Result<Option<LightningReceive>>

Fetches the status of a lightning receive for the given PaymentHash.

Source

pub async fn try_claim_lightning_receive( &self, payment_hash: PaymentHash, wait: bool, token: Option<&str>, ) -> Result<LightningReceive>

Check and claim a Lightning receive

This function checks for an incoming lightning payment with the given PaymentHash and then claims the payment using returned HTLC VTXOs.

§Arguments
  • payment_hash - The PaymentHash of the lightning payment to check for.
  • wait - Whether to wait for the payment to be received.
  • token - An optional lightning receive token used to authenticate a lightning receive when no spendable VTXOs are owned by this wallet.
§Returns

Returns an anyhow::Result<LightningReceive>, which is:

  • Ok(LightningReceive) if the claim was completed or is awaiting HTLC VTXOs
  • Err if an error occurs at any stage of the operation.
§Remarks
Source

pub async fn try_claim_all_lightning_receives(&self, wait: bool) -> Result<()>

Check and claim all opened Lightning receive

This function fetches all opened lightning receives and then concurrently tries to check and claim them.

§Arguments
  • wait - Whether to wait for each payment to be received.
§Returns

Returns an anyhow::Result<()>, which is:

  • Ok(()) if at least one claim succeeded or there were no pending receives.
  • Err if all claim attempts failed.
Source§

impl Wallet

Source

pub async fn offboard_all(&self, address: Address) -> Result<Txid>

Offboard all VTXOs to a given bitcoin::Address.

Source

pub async fn offboard_vtxos<V: VtxoRef>( &self, vtxos: impl IntoIterator<Item = V>, address: Address, ) -> Result<Txid>

Offboard the given VTXOs to a given bitcoin::Address.

Source§

impl Wallet

Source

pub fn chain_source(config: &Config) -> Result<ChainSourceSpec>

Creates a chain::ChainSource instance to communicate with an onchain backend from the given Config.

Source

pub fn require_chainsource_version(&self) -> Result<()>

Verifies that the bark Wallet can be used with the configured chain::ChainSource. More specifically, if the chain::ChainSource connects to Bitcoin Core it must be a high enough version to support ephemeral anchors.

Source

pub async fn network(&self) -> Result<Network>

Source

pub async fn derive_store_next_keypair(&self) -> Result<(Keypair, u32)>

Derive and store the keypair directly after currently last revealed one, together with its index.

Source

pub async fn peak_keypair(&self, index: u32) -> Result<Keypair>

Retrieves a keypair based on the provided index and checks if the corresponding public key exists in the Vtxo database.

§Arguments
  • index - The index used to derive a keypair.
§Returns
  • Ok(Keypair) - If the keypair is successfully derived and its public key exists in the database.
  • Err(anyhow::Error) - If the public key does not exist in the database or if an error occurs during the database query.
Source

pub async fn pubkey_keypair( &self, public_key: &PublicKey, ) -> Result<Option<(u32, Keypair)>>

Retrieves the Keypair for a provided PublicKey

§Arguments
  • public_key - The public key for which the keypair must be found
§Returns
  • Ok(Some(u32, Keypair)) - If the pubkey is found, the derivation-index and keypair are returned
  • Ok(None) - If the pubkey cannot be found in the database
  • Err(anyhow::Error) - If an error occurred related to the database query
Source

pub async fn get_vtxo_key(&self, vtxo: impl VtxoRef) -> Result<Keypair>

Retrieves the Keypair for a provided Vtxo

§Arguments
  • vtxo - The vtxo for which the key must be found
§Returns
  • Ok(Some(Keypair)) - If the pubkey is found, the keypair is returned
  • Err(anyhow::Error) - If the corresponding public key doesn’t exist in the database or a database error occurred.
Source

pub async fn new_address(&self) -> Result<Address>

Generate a new ark::Address.

Source

pub async fn peak_address(&self, index: u32) -> Result<Address>

Peak for an ark::Address at the given key index.

May return an error if the address at the given index has not been derived yet.

Source

pub async fn new_address_with_index(&self) -> Result<(Address, u32)>

Generate a new ark::Address and returns the index of the key used to create it.

This derives and stores the keypair directly after currently last revealed one.

Source

pub async fn create( mnemonic: &Mnemonic, network: Network, config: Config, db: Arc<dyn BarkPersister>, force: bool, ) -> Result<Wallet>

Create a new wallet without an optional onchain backend. This will restrict features such as boarding and unilateral exit.

The force flag will allow you to create the wallet even if a connection to the Ark server cannot be established, it will not overwrite a wallet which has already been created.

Source

pub async fn create_with_onchain( mnemonic: &Mnemonic, network: Network, config: Config, db: Arc<dyn BarkPersister>, onchain: &dyn ExitUnilaterally, force: bool, ) -> Result<Wallet>

Create a new wallet with an onchain backend. This enables full Ark functionality. A default implementation of an onchain wallet when the onchain_bdk feature is enabled. See onchain::OnchainWallet for more details. Alternatively, implement ExitUnilaterally if you have your own onchain wallet implementation.

The force flag will allow you to create the wallet even if a connection to the Ark server cannot be established, it will not overwrite a wallet which has already been created.

Source

pub async fn open( mnemonic: &Mnemonic, db: Arc<dyn BarkPersister>, config: Config, ) -> Result<Wallet>

Loads the bark wallet from the given database ensuring the fingerprint remains consistent.

Source

pub async fn open_with_onchain( mnemonic: &Mnemonic, db: Arc<dyn BarkPersister>, onchain: &dyn ExitUnilaterally, cfg: Config, ) -> Result<Wallet>

Similar to Wallet::open however this also unilateral exits using the provided onchain wallet.

Source

pub fn config(&self) -> &Config

Returns the config used to create/load the bark Wallet.

Source

pub async fn properties(&self) -> Result<WalletProperties>

Retrieves the WalletProperties of the current bark Wallet.

Source

pub fn fingerprint(&self) -> Fingerprint

Returns the fingerprint of the wallet.

Source

pub async fn refresh_server(&self) -> Result<()>

Source

pub async fn ark_info(&self) -> Result<Option<ArkInfo>>

Return ArkInfo fetched on last handshake with the Ark server

Source

pub async fn balance(&self) -> Result<Balance>

Return the Balance of the wallet.

Make sure you sync before calling this method.

Source

pub async fn validate_vtxo(&self, vtxo: &Vtxo) -> Result<()>

Fetches Vtxo’s funding transaction and validates the VTXO against it.

Source

pub async fn get_vtxo_by_id(&self, vtxo_id: VtxoId) -> Result<WalletVtxo>

Retrieves the full state of a Vtxo for a given VtxoId if it exists in the database.

Source

pub async fn movements(&self) -> Result<Vec<Movement>>

👎Deprecated since 0.1.0-beta.5: Use Wallet::history instead

Fetches all movements ordered from newest to oldest.

Source

pub async fn history(&self) -> Result<Vec<Movement>>

Fetches all wallet fund movements ordered from newest to oldest.

Source

pub async fn all_vtxos(&self) -> Result<Vec<WalletVtxo>>

Returns all VTXOs from the database.

Source

pub async fn vtxos(&self) -> Result<Vec<WalletVtxo>>

Returns all not spent vtxos

Source

pub async fn vtxos_with( &self, filter: &impl FilterVtxos, ) -> Result<Vec<WalletVtxo>>

Returns all vtxos matching the provided predicate

Source

pub async fn spendable_vtxos(&self) -> Result<Vec<WalletVtxo>>

Returns all spendable vtxos

Source

pub async fn spendable_vtxos_with( &self, filter: &impl FilterVtxos, ) -> Result<Vec<WalletVtxo>>

Returns all spendable vtxos matching the provided predicate

Source

pub async fn pending_boards(&self) -> Result<Vec<PendingBoard>>

Source

pub async fn pending_board_vtxos(&self) -> Result<Vec<WalletVtxo>>

Queries the database for any VTXO that is an unregistered board. There is a lag time between when a board is created and when it becomes spendable.

See ArkInfo::required_board_confirmations and Wallet::sync_pending_boards.

Source

pub async fn pending_round_input_vtxos(&self) -> Result<Vec<WalletVtxo>>

Returns all VTXOs that are locked in a pending round

This excludes all input VTXOs for which the output VTXOs have already been created.

Source

pub async fn pending_lightning_send_vtxos(&self) -> Result<Vec<WalletVtxo>>

Queries the database for any VTXO that is a pending lightning send.

Source

pub async fn get_expiring_vtxos( &self, threshold: BlockHeight, ) -> Result<Vec<WalletVtxo>>

Returns all vtxos that will expire within threshold blocks

Source

pub async fn sync_pending_boards(&self) -> Result<()>

Attempts to register all pendings boards with the Ark server. A board transaction must have sufficient confirmations before it will be registered. For more details see ArkInfo::required_board_confirmations.

Source

pub async fn maintenance(&self) -> Result<()>

Performs maintenance tasks on the offchain wallet.

This can take a long period of time due to syncing rounds, arkoors, checking pending payments, progressing pending rounds, and refreshing VTXOs if necessary.

Source

pub async fn maintenance_with_onchain<W: PreparePsbt + SignPsbt + ExitUnilaterally>( &self, onchain: &mut W, ) -> Result<()>

Performs maintenance tasks on the onchain and offchain wallet.

This can take a long period of time due to syncing the onchain wallet, registering boards, syncing rounds, arkoors, and the exit system, checking pending lightning payments and refreshing VTXOs if necessary.

Source

pub async fn maybe_schedule_maintenance_refresh( &self, ) -> Result<Option<RoundStateId>>

Checks VTXOs that are due to be refreshed, and schedules a refresh if any

This will include any VTXOs within the expiry threshold (Config::vtxo_refresh_expiry_threshold) or those which are uneconomical to exit due to onchain network conditions.

Returns a RoundStateId if a refresh is scheduled.

Source

pub async fn maintenance_refresh(&self) -> Result<Option<RoundStatus>>

Performs a refresh of all VTXOs that are due to be refreshed, if any. This will include any VTXOs within the expiry threshold (Config::vtxo_refresh_expiry_threshold) or those which are uneconomical to exit due to onchain network conditions.

Returns a RoundStatus if a refresh occurs.

Source

pub async fn sync(&self)

Sync offchain wallet and update onchain fees. This is a much more lightweight alternative to Wallet::maintenance as it will not refresh VTXOs or sync the onchain wallet.

Notes:

  • The exit system will not be synced as doing so requires the onchain wallet.
Source

pub async fn sync_exits(&self, onchain: &mut dyn ExitUnilaterally) -> Result<()>

Sync the transaction status of unilateral exits

This will not progress the unilateral exits in any way, it will merely check the transaction status of each transaction as well as check whether any exits have become claimable or have been claimed.

Source

pub async fn pending_lightning_sends(&self) -> Result<Vec<LightningSend>>

Source

pub async fn sync_pending_lightning_send_vtxos(&self) -> Result<()>

Syncs pending lightning payments, verifying whether the payment status has changed and creating a revocation VTXO if necessary.

Source

pub async fn dangerous_drop_vtxo(&self, vtxo_id: VtxoId) -> Result<()>

Drop a specific Vtxo from the database. This is destructive and will result in a loss of funds.

Source

pub async fn dangerous_drop_all_vtxos(&self) -> Result<()>

Drop all VTXOs from the database. This is destructive and will result in a loss of funds.

Source

pub async fn board_amount( &self, onchain: &mut dyn Board, amount: Amount, ) -> Result<PendingBoard>

Board a Vtxo with the given amount.

NB we will spend a little more onchain to cover fees.

Source

pub async fn board_all(&self, onchain: &mut dyn Board) -> Result<PendingBoard>

Board a Vtxo with all the funds in your onchain wallet.

Source

pub async fn sync_oors(&self) -> Result<()>

Source

pub async fn build_refresh_participation<V: VtxoRef>( &self, vtxos: impl IntoIterator<Item = V>, ) -> Result<Option<RoundParticipation>>

Source

pub async fn refresh_vtxos<V: VtxoRef>( &self, vtxos: impl IntoIterator<Item = V>, ) -> Result<Option<RoundStatus>>

This will refresh all provided VTXOs. Note that attempting to refresh a board VTXO which has not yet confirmed will result in an error.

Returns the RoundStatus of the round if a successful refresh occurred. It will return None if no Vtxo needed to be refreshed.

Source

pub async fn get_vtxos_to_refresh(&self) -> Result<Vec<WalletVtxo>>

This will find all VTXOs that meets must-refresh criteria. Then, if there are some VTXOs to refresh, it will also add those that meet should-refresh criteria.

Source

pub async fn get_first_expiring_vtxo_blockheight( &self, ) -> Result<Option<BlockHeight>>

Returns the block height at which the first VTXO will expire

Source

pub async fn get_next_required_refresh_blockheight( &self, ) -> Result<Option<BlockHeight>>

Returns the next block height at which we have a VTXO that we want to refresh

Source

pub async fn pending_lightning_receives(&self) -> Result<Vec<LightningReceive>>

Fetches all pending lightning receives ordered from newest to oldest.

Source

pub async fn claimable_lightning_receive_balance(&self) -> Result<Amount>

Source

pub async fn run_daemon( self: &Arc<Self>, onchain: Arc<RwLock<dyn DaemonizableOnchainWallet>>, ) -> Result<DaemonHandle>

Starts a daemon for the wallet.

Note:

  • This function doesn’t check if a daemon is already running, so it’s possible to start multiple daemons by mistake.

Trait Implementations§

Source§

impl VtxoSigner for Wallet

Source§

fn witness<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, clause: &'life1 VtxoClause, control_block: &'life2 ControlBlock, sighash: TapSighash, ) -> Pin<Box<dyn Future<Output = Option<Witness>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns the witness for a VtxoClause if it is signable, otherwise None.
Source§

fn can_sign<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, clause: &'life1 VtxoClause, vtxo: &'life2 Vtxo, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Returns true if the clause is signable, otherwise false.
Source§

fn find_signable_clause<'life0, 'life1, 'async_trait>( &'life0 self, vtxo: &'life1 Vtxo, ) -> Pin<Box<dyn Future<Output = Option<VtxoClause>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Returns the first signable clause from Vtxo’s policy. If no clause is signable, returns None.
Source§

fn sign_input<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, vtxo: &'life1 Vtxo, input_idx: usize, sighash_cache: &'life2 mut SighashCache<impl Borrow<Transaction> + Send + Sync + 'async_trait>, prevouts: &'life3 Prevouts<'_, impl Borrow<TxOut> + Send + Sync + 'async_trait>, ) -> Pin<Box<dyn Future<Output = Result<Witness, CannotSignVtxoError>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Return the full witness for a Vtxo using the first signable clause. Read more
Source§

fn sign_input_with_clause<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, vtxo: &'life1 Vtxo, clause: &'life2 VtxoClause, input_idx: usize, sighash_cache: &'life3 mut SighashCache<impl Borrow<Transaction> + Send + Sync + 'async_trait>, prevouts: &'life4 Prevouts<'_, impl Borrow<TxOut> + Send + Sync + 'async_trait>, ) -> Pin<Box<dyn Future<Output = Result<Witness, CannotSignVtxoError>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: Sync + 'async_trait,

Return the full witness for a Vtxo using the specified clause. Read more

Auto Trait Implementations§

§

impl !Freeze for Wallet

§

impl !RefUnwindSafe for Wallet

§

impl Send for Wallet

§

impl Sync for Wallet

§

impl Unpin for Wallet

§

impl !UnwindSafe for Wallet

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<L> LayerExt<L> for L

Source§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in Layered.
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more