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<dyn IGatewayClientV2>,
}

Fields

federation_id: FederationId

cfg: LightningClientConfig

notifier: ModuleNotifier<GatewayClientStateMachinesV2>

client_ctx: ClientContext<Self>

module_api: DynModuleApi

keypair: Keypair

gateway: Arc<dyn IGatewayClientV2>

Implementations

impl GatewayClientModuleV2

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

Starts paying the invoice of an LNv2 outgoing contract, or joins the payment already under way for it, and waits for its outcome.

The Ok value is that outcome: the preimage if the payment succeeded, or the gateway’s forfeit signature, which lets the sender reclaim the contract, if it was cancelled.

Errors

Fails with a GatewaySendPaymentError if the request is refused before any payment starts: the gateway is not connected to its lightning node, the contract is another gateway’s, the request’s signature does not verify, the federation has not confirmed this contract at that outpoint or cannot be asked, the invoice has no amount or does not match the contract, the gateway cannot price the payment, or another contract already claimed the payment image.

pub(crate) async fn await_outgoing_contract_max_delay( &self, outpoint: OutPoint, ) -> u64

Returns the timelock budget, in blocks, that the outgoing contract at outpoint leaves for a payment dispatched now, retrying until the federation answers. A contract the federation no longer knows leaves no budget.

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

pub(crate) async fn legacy_completion_exists( &self, operation_id: OperationId, circuit: IncomingCircuitKey, ) -> bool

pub(crate) async fn ensure_federation_responsive( &self, payment_hash: Hash, ) -> Result<(), RelayIncomingHtlcError>

Refuses to fund a fresh incoming contract unless a threshold of guardians is answering. LNv1 gets this check implicitly by fetching the offer from the federation first; LNv2 reads the contract from the gateway’s own database, so it has to probe explicitly.

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

Funds the incoming contract of an intercepted LNv2 HTLC and starts the operation that completes the HTLC’s circuit.

A contract or circuit that is already being handled is joined rather than started twice.

Errors

Fails with a RelayIncomingHtlcError if a fresh contract is not funded because the HTLC’s claim deadline is too close or the federation does not answer, or if the funding transaction or the completion operation could not be started and no earlier attempt had started it.

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

Funds the incoming contract of a direct swap and waits for its final state.

A swap that was already started resumes unconditionally: its operation is keyed on the contract, so a re-entrant call — a restarted state machine, or a concurrent payer — joins the operation in progress instead of funding twice. allow_fresh_dispatch is consulted only when no such operation exists: callers pass false when a wall-clock gate such as invoice expiry forbids starting a new swap, and receive Ok(None) to signal that nothing was started.

Errors

Fails with a TransactionSubmitError if the funding transaction of a fresh swap could not be submitted.

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

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

Waits for a legacy combined receive operation or a circuit-completion operation to finish.

operation_id must identify either a legacy operation containing GatewayClientStateMachinesV2::Complete or a role-specific operation containing GatewayClientStateMachinesV2::CircuitComplete. Both successful completion and a durable permanent outcome conflict terminate the wait.

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: &Amounts, _input: &<Self::Common as ModuleCommon>::Input, ) -> Option<Amounts>

Returns the fee the processing of this input requires.

fn output_fee( &self, _amount: &Amounts, output: &<Self::Common as ModuleCommon>::Output, ) -> Option<Amounts>

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, ClientModuleError>> + Send + 'async_trait>>

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

Runs a fedimint-cli module command, given as its arguments.

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

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

Serves a JSON request, such as one fedimint-client-rpc forwards.

fn supports_backup(&self) -> bool

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

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

The module’s part of a client backup.

fn supports_being_primary(&self) -> PrimaryModuleSupport

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, _unit: AmountUnit, _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>), ClientModuleError>> + 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.

fn await_primary_module_output<'life0, 'async_trait>( &'life0 self, _operation_id: OperationId, _out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<(), ClientModuleError>> + 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>, _unit: AmountUnit, ) -> 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 get_balances<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Amounts> + 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<(), ClientModuleError>> + 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 duplicate 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.