Struct GatewayClientModuleV2

pub struct GatewayClientModuleV2 {
    pub federation_id: FederationId,
    pub cfg: LightningClientConfig,
    pub notifier: ModuleNotifier<GatewayClientStateMachinesV2>,
    pub client_ctx: ClientContext<Self>,
    pub module_api: DynModuleApi,
    pub keypair: Keypair,
    pub gateway: Arc<Gateway>,
}

Fields

federation_id: FederationId

cfg: LightningClientConfig

notifier: ModuleNotifier<GatewayClientStateMachinesV2>

client_ctx: ClientContext<Self>

module_api: DynModuleApi

keypair: Keypair

gateway: Arc<Gateway>

Implementations

impl GatewayClientModuleV2

pub async fn send_payment( &self, payload: SendPaymentPayload, ) -> Result<Result<[u8; 32], Signature>>

pub async fn subscribe_send( &self, operation_id: OperationId, ) -> Result<[u8; 32], Signature>

pub async fn relay_incoming_htlc( &self, payment_hash: Hash, incoming_chan_id: u64, htlc_id: u64, contract: IncomingContract, amount_msat: u64, ) -> Result<()>

pub async fn relay_direct_swap( &self, contract: IncomingContract, amount_msat: u64, ) -> Result<FinalReceiveState>

async fn await_receive(&self, operation_id: OperationId) -> FinalReceiveState

pub async fn await_completion(&self, operation_id: OperationId)

For the given OperationId, this function will wait until the Complete state machine has finished or failed.

Trait Implementations

impl ClientModule for GatewayClientModuleV2

type Init = GatewayClientInitV2

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 = GatewayClientContextV2

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

type States = GatewayClientStateMachinesV2

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 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_cli_command<'life0, 'life1, 'async_trait>( &'life0 self, _args: &'life1 [OsString], ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

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

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 Clone for GatewayClientModuleV2

fn clone(&self) -> GatewayClientModuleV2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GatewayClientModuleV2

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

Formats the value using the given formatter.