Struct LexeWallet

pub struct LexeWallet { /* private fields */ }

Top-level handle to a Lexe wallet.

Implementations

impl LexeWallet

pub fn fresh( env_config: WalletEnvConfig, credentials: CredentialsRef<'_>, lexe_data_dir: Option<PathBuf>, ) -> Result<Self>

Create a fresh LexeWallet, deleting any existing database state for this user. Data for other users and environments is not affected.

It is recommended to always pass the same lexe_data_dir, regardless of which environment we’re in (dev/staging/prod) and which user this LexeWallet is for. Users and environments will not interfere with each other as all data is namespaced internally. Defaults to ~/.lexe if not specified.

pub fn load( env_config: WalletEnvConfig, credentials: CredentialsRef<'_>, lexe_data_dir: Option<PathBuf>, ) -> Result<Option<Self>>

Load an existing LexeWallet with persistence from lexe_data_dir. Returns None if no local data exists, in which case you should use fresh to create the wallet and local data cache.

If you are authenticating with RootSeeds and this returns None, you should call signup after creating the wallet if you’re not sure whether the user has been signed up with Lexe.

It is recommended to always pass the same lexe_data_dir, regardless of which environment we’re in (dev/staging/prod) and which user this LexeWallet is for. Users and environments will not interfere with each other as all data is namespaced internally. Defaults to ~/.lexe if not specified.

pub fn load_or_fresh( env_config: WalletEnvConfig, credentials: CredentialsRef<'_>, lexe_data_dir: Option<PathBuf>, ) -> Result<Self>

Load an existing LexeWallet with persistence from lexe_data_dir, or create a fresh one if no local data exists. If you are authenticating with client credentials, this is generally what you want to use.

It is recommended to always pass the same lexe_data_dir, regardless of which environment we’re in (dev/staging/prod) and which user this LexeWallet is for. Users and environments will not interfere with each other as all data is namespaced internally. Defaults to ~/.lexe if not specified.

pub fn without_db( env_config: WalletEnvConfig, credentials: CredentialsRef<'_>, ) -> Result<Self>

Create a LexeWallet without any persistence. It is recommended to use fresh or load instead, to initialize with persistence.

Node operations (invoices, payments, node info) work normally. Local payment cache operations (sync_payments, list_payments, clear_payments) are not available and will return an error.

pub async fn sync_payments(&self) -> Result<PaymentSyncSummary>

Sync payments from the user node to the local database. This fetches updated payments from the node and persists them locally.

Returns an error if this wallet was created without local persistence.

pub fn list_payments( &self, filter: &PaymentFilter, order: Option<Order>, limit: Option<usize>, after: Option<&PaymentCreatedIndex>, ) -> Result<ListPaymentsResponse>

List payments from local storage with cursor-based pagination.

Defaults to descending order (newest first) with a limit of 100.

To continue paginating, set after to the next_index from the previous response. after is an exclusive index.

If needed, use sync_payments to fetch the latest data from the node before calling this method.

Returns an error if this wallet was created without local persistence.

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

Clear all local payment data for this wallet.

Clears the local payment cache only. Remote data on the node is not affected. Call sync_payments to re-populate.

Returns an error if this wallet was created without local persistence.

pub async fn wait_for_payment( &self, index: PaymentCreatedIndex, timeout: Option<Duration>, ) -> Result<Payment>

Wait for a payment to reach a terminal state (completed or failed).

Polls the node with exponential backoff until the payment finalizes or the timeout is reached. Defaults to 10 minutes if not specified. Maximum timeout is 86,400 seconds (24 hours).

pub async fn signup( &self, root_seed: &RootSeed, partner_pk: Option<UserPk>, ) -> Result<()>

Registers this user with Lexe, then provisions the node. This method must be called after the user’s LexeWallet has been created for the first time, otherwise subsequent requests will fail.

It is only necessary to call this method once, ever, per user, but it is also okay to call this method even if the user has already been signed up; in other words, this method is idempotent.

After a successful signup, make sure the user’s root seed has been persisted somewhere! Without access to their root seed, your user will lose their funds forever. If adding Lexe to a broader wallet, a good strategy is to derive Lexe’s RootSeed from your own root seed.

• partner_pk: Set to your company’s UserPk to earn a share of this wallet’s fees.

pub async fn provision(&self, credentials: CredentialsRef<'_>) -> Result<()>

Ensures the wallet is provisioned to all recent trusted releases. This should be called every time the wallet is loaded, to ensure the user is running the most up-to-date enclave software.

This fetches the current enclaves from the gateway, computes which releases need to be provisioned, and provisions them.

pub fn user_config(&self) -> &WalletUserConfig

Get a reference to the user’s wallet configuration.

pub async fn node_info(&self) -> Result<NodeInfo>

Get information about this Lexe node, including balance and channels.

pub async fn create_invoice( &self, req: CreateInvoiceRequest, ) -> Result<CreateInvoiceResponse>

Create a BOLT 11 invoice to receive a Lightning payment.

pub async fn pay_invoice( &self, req: PayInvoiceRequest, ) -> Result<PayInvoiceResponse>

Pay a BOLT 11 invoice over Lightning.

pub async fn get_payment( &self, req: GetPaymentRequest, ) -> Result<GetPaymentResponse>

Get information about a payment by its created index.

pub async fn update_payment_note( &self, req: UpdatePaymentNoteRequest, ) -> Result<()>

Update the personal note on an existing payment. The note is stored on the user node and is not visible to the counterparty.