Struct LightningClientModule

pub struct LightningClientModule {
    pub(crate) federation_id: FederationId,
    pub(crate) cfg: LightningClientConfig,
    pub(crate) notifier: ModuleNotifier<LightningClientStateMachines>,
    pub(crate) client_ctx: ClientContext<Self>,
    pub(crate) module_api: DynModuleApi,
    pub(crate) keypair: Keypair,
    pub(crate) gateway_conn: Arc<dyn GatewayConnection + Send + Sync>,
    pub(crate) admin_auth: Option<ApiAuth>,
}

Fields

federation_id: FederationId

cfg: LightningClientConfig

notifier: ModuleNotifier<LightningClientStateMachines>

client_ctx: ClientContext<Self>

module_api: DynModuleApi

keypair: Keypair

gateway_conn: Arc<dyn GatewayConnection + Send + Sync>

admin_auth: Option<ApiAuth>

Implementations

impl LightningClientModule

pub(crate) fn new( federation_id: FederationId, cfg: LightningClientConfig, notifier: ModuleNotifier<LightningClientStateMachines>, client_ctx: ClientContext<Self>, module_api: DynModuleApi, keypair: Keypair, gateway_conn: Arc<dyn GatewayConnection + Send + Sync>, admin_auth: Option<ApiAuth>, task_group: &TaskGroup, ) -> Self

pub(crate) fn spawn_gateway_map_update_task( federation_id: FederationId, client_ctx: ClientContext<Self>, module_api: DynModuleApi, gateway_conn: Arc<dyn GatewayConnection + Send + Sync>, task_group: &TaskGroup, )

pub(crate) async fn update_gateway_map( federation_id: &FederationId, client_ctx: &ClientContext<Self>, module_api: &DynModuleApi, gateway_conn: &Arc<dyn GatewayConnection + Send + Sync>, )

pub(crate) async fn select_gateway( &self, invoice: Option<Bolt11Invoice>, ) -> Result<(SafeUrl, RoutingInfo), SelectGatewayError>

pub(crate) async fn routing_info( &self, gateway: &SafeUrl, ) -> Result<Option<RoutingInfo>, GatewayConnectionError>

pub async fn send( &self, invoice: Bolt11Invoice, gateway: Option<SafeUrl>, custom_meta: Value, ) -> Result<OperationId, SendPaymentError>

Pay an invoice. For testing you can optionally specify a gateway to route with, otherwise a gateway will be selected automatically. If the invoice was created by a gateway connected to our federation, the same gateway will be selected to allow for a direct ecash swap. Otherwise we select a random online gateway.

The fee for this payment may depend on the selected gateway but will be limited to one and a half percent plus one hundred satoshis. This fee accounts for the fee charged by the gateway as well as the additional fee required to reliably route this payment over lightning if necessary. Since the gateway has been vetted by at least one guardian we trust it to set a reasonable fee and only enforce a rather high limit.

The absolute fee for a payment can be calculated from the operation meta to be shown to the user in the transaction history.

pub(crate) async fn get_next_operation_id( &self, invoice: &Bolt11Invoice, ) -> Result<OperationId, SendPaymentError>

pub async fn subscribe_send_operation_state_updates( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<SendOperationState>>

Subscribe to all state updates of the send operation.

pub async fn await_final_send_operation_state( &self, operation_id: OperationId, ) -> Result<FinalSendOperationState>

Await the final state of the send operation.

pub async fn receive( &self, amount: Amount, expiry_secs: u32, description: Bolt11InvoiceDescription, gateway: Option<SafeUrl>, custom_meta: Value, ) -> Result<(Bolt11Invoice, OperationId), ReceiveError>

Request an invoice. For testing you can optionally specify a gateway to generate the invoice, otherwise a random online gateway will be selected automatically.

The total fee for this payment may depend on the chosen gateway but will be limited to half of one percent plus fifty satoshis. Since the selected gateway has been vetted by at least one guardian we trust it to set a reasonable fee and only enforce a rather high limit.

The absolute fee for a payment can be calculated from the operation meta to be shown to the user in the transaction history.

pub(crate) async fn create_contract_and_fetch_invoice( &self, recipient_static_pk: PublicKey, amount: Amount, expiry_secs: u32, description: Bolt11InvoiceDescription, gateway: Option<SafeUrl>, ) -> Result<(SafeUrl, IncomingContract, Bolt11Invoice), ReceiveError>

Create an incoming contract locked to a public key derived from the recipient’s static module public key and fetches the corresponding invoice.

pub(crate) async fn receive_incoming_contract( &self, gateway: SafeUrl, contract: IncomingContract, invoice: Bolt11Invoice, custom_meta: Value, ) -> Option<OperationId>

pub(crate) fn recover_contract_keys( &self, contract: &IncomingContract, ) -> Option<(Keypair, AggregateDecryptionKey)>

pub async fn subscribe_receive_operation_state_updates( &self, operation_id: OperationId, ) -> Result<UpdateStreamOrOutcome<ReceiveOperationState>>

Subscribe to all state updates of the receive operation.

pub async fn await_final_receive_operation_state( &self, operation_id: OperationId, ) -> Result<FinalReceiveOperationState>

Await the final state of the receive operation.

Trait Implementations

impl ClientModule for LightningClientModule

type Init = LightningClientInit

type Common = LightningModuleTypes

Common module types shared between client and server

type Backup = NoModuleBackup

Data stored in regular backups so that restoring doesn’t have to start from epoch 0

type ModuleStateMachineContext = LightningClientContext

Data and API clients available to state machine transitions of this module

type States = LightningClientStateMachines

All possible states this client can submit to the executor

fn context(&self) -> Self::ModuleStateMachineContext

fn input_fee( &self, amount: Amount, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amount>

Returns the fee the processing of this input requires.

fn output_fee( &self, amount: Amount, _output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amount>

Returns the fee the processing of this output requires.

fn handle_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn decoder() -> Decoder

fn kind() -> ModuleKind

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Initialize client.

fn handle_rpc<'life0, 'async_trait>( &'life0 self, _method: String, _request: Value, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = Result<Value, Error>> + Send + 'life0>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn supports_backup(&self) -> bool

fn backup<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Self::Backup, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

fn supports_being_primary(&self) -> bool

Does this module support being a primary module

fn create_final_inputs_and_outputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, _operation_id: OperationId, _input_amount: Amount, _output_amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<(ClientInputBundle<<Self::Common as ModuleCommon>::Input, Self::States>, ClientOutputBundle<<Self::Common as ModuleCommon>::Output, Self::States>), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Creates all inputs and outputs necessary to balance the transaction. The function returns an error if and only if the client’s funds are not sufficient to create the inputs necessary to fully fund the transaction.

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, _operation_id: OperationId, _out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<Amount, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Waits for the funds from an output created by Self::create_final_inputs_and_outputs to become available. This function returning typically implies a change in the output of Self::get_balance.

fn get_balance<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amount> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Returns the balance held by this module and available for funding transactions.

fn subscribe_balance_changes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Pin<Box<dyn Stream<Item = ()> + Send>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Returns a stream that will output the updated module balance each time it changes.

fn leave<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Leave the federation

impl Debug for LightningClientModule

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

Formats the value using the given formatter.