Struct Lightning

pub struct Lightning {
    pub(crate) cfg: LightningConfig,
    pub(crate) btc_rpc: DynBitcoindRpc,
    pub(crate) our_peer_id: PeerId,
}

The lightning module implements an account system. It does not have the privacy guarantees of the e-cash mint module but instead allows for smart contracting. There exist two contract types that can be used to “lock” accounts:

• Outgoing: an account locked with an HTLC-like contract allowing to incentivize an external Lightning node to make payments for the funder
• Incoming: a contract type that represents the acquisition of a preimage belonging to a hash. Every incoming contract is preceded by an offer that specifies how much the seller is asking for the preimage to a particular hash. It also contains some threshold-encrypted data. Once the contract is funded the data is decrypted. If it is a valid preimage the contract’s funds are now accessible to the creator of the offer, if not they are accessible to the funder.

These two primitives allow to integrate the federation with the wider Lightning network through a centralized but untrusted (except for availability) Lightning gateway server.

Fields

cfg: LightningConfig

btc_rpc: DynBitcoindRpc

our_peer_id: PeerId

Implementations

impl Lightning

pub(crate) fn new( cfg: LightningConfig, task_group: &TaskGroup, our_peer_id: PeerId, ) -> Result<Self>

pub(crate) async fn block_count(&self) -> Result<u64>

pub(crate) async fn consensus_block_count( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> u64

pub(crate) async fn wait_block_height( &self, block_height: u64, dbtx: &mut DatabaseTransaction<'_>, )

pub(crate) fn validate_decryption_share( &self, peer: PeerId, share: &PreimageDecryptionShare, message: &EncryptedPreimage, ) -> bool

pub(crate) async fn get_offer( &self, dbtx: &mut DatabaseTransaction<'_>, payment_hash: Hash, ) -> Option<IncomingContractOffer>

pub(crate) async fn wait_offer( &self, context: &mut ApiEndpointContext<'_>, payment_hash: Hash, ) -> IncomingContractOffer

pub(crate) async fn get_contract_account( &self, dbtx: &mut DatabaseTransaction<'_>, contract_id: ContractId, ) -> Option<ContractAccount>

pub(crate) async fn wait_contract_account( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> ContractAccount

pub(crate) async fn wait_outgoing_contract_account_cancelled( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> ContractAccount

pub(crate) async fn get_decrypted_preimage_status( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> (IncomingContractAccount, DecryptedPreimageStatus)

pub(crate) async fn wait_preimage_decrypted( &self, context: &mut ApiEndpointContext<'_>, contract_id: ContractId, ) -> (IncomingContractAccount, Option<Preimage>)

pub(crate) fn get_incoming_contract_account( contract: ContractAccount, ) -> IncomingContractAccount

pub(crate) async fn list_gateways( &self, dbtx: &mut DatabaseTransaction<'_>, ) -> Vec<LightningGatewayAnnouncement>

pub(crate) async fn register_gateway( &self, dbtx: &mut DatabaseTransaction<'_>, gateway: LightningGatewayAnnouncement, )

pub(crate) async fn delete_expired_gateways( &self, dbtx: &mut DatabaseTransaction<'_>, )

pub(crate) async fn get_gateway_remove_challenge( &self, gateway_id: PublicKey, dbtx: &mut DatabaseTransaction<'_>, ) -> Option<Hash>

Returns the challenge to the gateway that must be signed by the gateway’s private key in order for the gateway registration record to be removed. The challenge is the concatenation of the gateway’s public key and the valid_until bytes. This ensures that the challenges changes every time the gateway is re-registered and ensures that the challenge is unique per-gateway.

pub(crate) async fn remove_gateway( &self, remove_gateway_request: RemoveGatewayRequest, dbtx: &mut DatabaseTransaction<'_>, ) -> Result<()>

Removes the gateway registration record. First the signature provided by the gateway is verified by checking if the gateway’s challenge has been signed by the gateway’s private key.

Trait Implementations

impl Debug for Lightning

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

Formats the value using the given formatter.

impl ServerModule for Lightning

type Common = LightningModuleTypes

type Init = LightningInit

fn consensus_proposal<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, ) -> Pin<Box<dyn Future<Output = Vec<LightningConsensusItem>> + Send + 'async_trait>>

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

This module’s contribution to the next consensus proposal. This method is only guaranteed to be called once every few seconds. Consensus items are not meant to be latency critical; do not create them as a response to a processed transaction. Only use consensus items to establish consensus on a value that is required to verify transactions, like unix time, block heights and feerates, and model all other state changes trough transactions. The intention for this method is to always return all available consensus items even if they are redundant while process_consensus_item returns an error for the redundant proposals.

fn process_consensus_item<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, consensus_item: LightningConsensusItem, peer_id: PeerId, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

This function is called once for every consensus item. The function should return Ok if and only if the consensus item changes the system state. Therefore this method should return an error in case of merely redundant consensus items such that they will be purged from the history of the federation. This enables consensus_proposal to return all available consensus item without wasting disk space with redundant consensus items.

fn process_input<'a, 'b, 'c, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'c>, input: &'b LightningInput, ) -> Pin<Box<dyn Future<Output = Result<InputMeta, LightningInputError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'c: 'async_trait, 'life0: 'async_trait,

Try to spend a transaction input. On success all necessary updates will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

fn process_output<'a, 'b, 'life0, 'async_trait>( &'a self, dbtx: &'life0 mut DatabaseTransaction<'b>, output: &'a LightningOutput, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Result<TransactionItemAmount, LightningOutputError>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'b: 'async_trait, 'life0: 'async_trait,

Try to create an output (e.g. issue notes, peg-out BTC, …). On success all necessary updates to the database will be part of the database transaction. On failure (e.g. double spend) the database transaction is rolled back and the operation will take no effect.

fn output_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, out_point: OutPoint, ) -> Pin<Box<dyn Future<Output = Option<LightningOutputOutcome>> + Send + 'async_trait>>

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

Retrieve the current status of the output. Depending on the module this might contain data needed by the client to access funds or give an estimate of when funds will be available. Returns None if the output is unknown, NOT if it is just not ready yet.

fn audit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dbtx: &'life1 mut DatabaseTransaction<'life2>, audit: &'life3 mut Audit, module_instance_id: ModuleInstanceId, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

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

Queries the database and returns all assets and liabilities of the module.

fn api_endpoints(&self) -> Vec<ApiEndpoint<Self>>

Returns a list of custom API endpoints defined by the module. These are made available both to users as well as to other modules. They thus should be deterministic, only dependant on their input and the current epoch.

fn module_kind() -> ModuleKind

fn decoder() -> Decoder

Returns a decoder for the following associated types of this module:

fn verify_input( &self, _input: &<Self::Common as ModuleCommon>::Input, ) -> Result<(), <Self::Common as ModuleCommon>::InputError>