Struct Gateway 

pub struct Gateway {

    pub(crate) federation_manager: Arc<RwLock<FederationManager>>,
    pub(crate) mnemonic: Mnemonic,
    pub(crate) lightning_mode: LightningMode,
    pub(crate) state: Arc<RwLock<GatewayState>>,
    pub(crate) client_builder: GatewayClientBuilder,
    pub(crate) gateway_db: Database,
    pub(crate) gateway_id: PublicKey,
    pub(crate) versioned_api: SafeUrl,
    pub(crate) listen: SocketAddr,
    pub(crate) task_group: TaskGroup,
    pub(crate) bcrypt_password_hash: Arc<HashParts>,
    pub(crate) num_route_hints: u32,
    pub(crate) network: Network,
    pub(crate) chain_source: ChainSource,
    pub(crate) default_routing_fees: PaymentFee,
    pub(crate) default_transaction_fees: PaymentFee,
    pub(crate) iroh_sk: SecretKey,
    pub(crate) iroh_listen: SocketAddr,
    pub(crate) iroh_dns: Option<SafeUrl>,
    pub(crate) iroh_relays: Vec<SafeUrl>,
}

Fields

federation_manager: Arc<RwLock<FederationManager>>

mnemonic: Mnemonic

lightning_mode: LightningMode

state: Arc<RwLock<GatewayState>>

client_builder: GatewayClientBuilder

gateway_db: Database

gateway_id: PublicKey

versioned_api: SafeUrl

listen: SocketAddr

task_group: TaskGroup

bcrypt_password_hash: Arc<HashParts>

num_route_hints: u32

network: Network

chain_source: ChainSource

default_routing_fees: PaymentFee

default_transaction_fees: PaymentFee

iroh_sk: SecretKey

iroh_listen: SocketAddr

iroh_dns: Option<SafeUrl>

iroh_relays: Vec<SafeUrl>

Implementations

impl Gateway

pub async fn new_with_custom_registry( lightning_mode: LightningMode, client_builder: GatewayClientBuilder, listen: SocketAddr, api_addr: SafeUrl, bcrypt_password_hash: HashParts, network: Network, num_route_hints: u32, gateway_db: Database, gateway_state: GatewayState, chain_source: ChainSource, iroh_listen: SocketAddr, ) -> Result<Gateway, Error>

Creates a new gateway but with a custom module registry provided inside client_builder. Currently only used for testing.

pub async fn new_with_default_modules() -> Result<Gateway, Error>

Default function for creating a gateway with the Mint, Wallet, and Gateway modules.

pub fn gateway_id(&self) -> PublicKey

pub fn versioned_api(&self) -> &SafeUrl

pub async fn dump_database( dbtx: &mut DatabaseTransaction<'_>, prefix_names: Vec<String>, ) -> BTreeMap<String, Box<dyn Serialize + Send>>

Reads and serializes structures from the Gateway’s database for the purpose for serializing to JSON for inspection.

pub async fn run( self, runtime: Arc<Runtime>, ) -> Result<TaskShutdownToken, Error>

Main entrypoint into the gateway that starts the client registration timer, loads the federation clients from the persisted config, begins listening for intercepted payments, and starts the webserver to service requests.

pub async fn handle_get_info(&self) -> Result<GatewayInfo, AdminGatewayError>

Returns information about the Gateway back to the client when requested via the webserver.

pub async fn handle_get_federation_config( &self, federation_id_or: Option<FederationId>, ) -> Result<GatewayFedConfig, AdminGatewayError>

If the Gateway is connected to the Lightning node, returns the ClientConfig for each federation that the Gateway is connected to.

pub async fn handle_address_msg( &self, payload: DepositAddressPayload, ) -> Result<Address, AdminGatewayError>

Returns a Bitcoin deposit on-chain address for pegging in Bitcoin for a specific connected federation.

pub async fn handle_withdraw_msg( &self, payload: WithdrawPayload, ) -> Result<WithdrawResponse, AdminGatewayError>

Returns a Bitcoin TXID from a peg-out transaction for a specific connected federation.

pub async fn handle_connect_federation( &self, payload: ConnectFedPayload, ) -> Result<FederationInfo, AdminGatewayError>

Handles a connection request to join a new federation. The gateway will download the federation’s client configuration, construct a new client, registers, the gateway with the federation, and persists the necessary config to reconstruct the client when restarting the gateway.

pub async fn handle_leave_federation( &self, payload: LeaveFedPayload, ) -> Result<FederationInfo, AdminGatewayError>

Handle a request to have the Gateway leave a federation. The Gateway will request the federation to remove the registration record and the gateway will remove the configuration needed to construct the federation client.

pub async fn handle_backup_msg( &self, __arg1: BackupPayload, ) -> Result<(), AdminGatewayError>

Handles a request for the gateway to backup a connected federation’s ecash.

pub async fn handle_mnemonic_msg( &self, ) -> Result<MnemonicResponse, AdminGatewayError>

Handles an authenticated request for the gateway’s mnemonic. This also returns a vector of federations that are not using the mnemonic backup strategy.

pub async fn handle_set_fees_msg( &self, __arg1: SetFeesPayload, ) -> Result<(), AdminGatewayError>

Handles a request to change the lightning or transaction fees for all federations or a federation specified by the FederationId.

pub async fn handle_get_ln_onchain_address_msg( &self, ) -> Result<Address, AdminGatewayError>

Generates an onchain address to fund the gateway’s lightning node.

pub async fn handle_open_channel_msg( &self, payload: OpenChannelRequest, ) -> Result<Txid, AdminGatewayError>

Instructs the Gateway’s Lightning node to open a channel to a peer specified by pubkey.

pub async fn handle_close_channels_with_peer_msg( &self, payload: CloseChannelsWithPeerRequest, ) -> Result<CloseChannelsWithPeerResponse, AdminGatewayError>

Instructs the Gateway’s Lightning node to close all channels with a peer specified by pubkey.

pub async fn handle_list_channels_msg( &self, ) -> Result<Vec<ChannelInfo>, AdminGatewayError>

Returns a list of Lightning network channels from the Gateway’s Lightning node.

pub async fn handle_send_onchain_msg( &self, payload: SendOnchainRequest, ) -> Result<Txid, AdminGatewayError>

Send funds from the gateway’s lightning node on-chain wallet.

pub async fn handle_recheck_address_msg( &self, payload: DepositAddressRecheckPayload, ) -> Result<(), AdminGatewayError>

Trigger rechecking for deposits on an address

pub async fn handle_get_balances_msg( &self, ) -> Result<GatewayBalances, AdminGatewayError>

Returns the ecash, lightning, and onchain balances for the gateway and the gateway’s lightning node.

pub async fn handle_spend_ecash_msg( &self, payload: SpendEcashPayload, ) -> Result<SpendEcashResponse, AdminGatewayError>

pub async fn handle_receive_ecash_msg( &self, payload: ReceiveEcashPayload, ) -> Result<ReceiveEcashResponse, PublicGatewayError>

Handles a request to receive ecash into the gateway.

pub async fn handle_shutdown_msg( &self, task_group: TaskGroup, ) -> Result<(), AdminGatewayError>

Instructs the gateway to shutdown, but only after all incoming payments have been handlded.

pub async fn handle_payment_log_msg( &self, __arg1: PaymentLogPayload, ) -> Result<PaymentLogResponse, AdminGatewayError>

Queries the client log for payment events and returns to the user.

pub async fn handle_payment_summary_msg( &self, __arg1: PaymentSummaryPayload, ) -> Result<PaymentSummaryResponse, AdminGatewayError>

Computes the 24 hour payment summary statistics for this gateway. Combines the LNv1 and LNv2 stats together.

pub async fn handle_get_invoice_msg( &self, payload: GetInvoiceRequest, ) -> Result<Option<GetInvoiceResponse>, AdminGatewayError>

Retrieves an invoice by the payment hash if it exists, otherwise returns None.

pub async fn handle_list_transactions_msg( &self, payload: ListTransactionsPayload, ) -> Result<ListTransactionsResponse, AdminGatewayError>

pub async fn handle_create_offer_for_operator_msg( &self, payload: CreateOfferPayload, ) -> Result<CreateOfferResponse, AdminGatewayError>

Creates a BOLT12 offer using the gateway’s lightning node

pub async fn handle_pay_offer_for_operator_msg( &self, payload: PayOfferPayload, ) -> Result<PayOfferResponse, AdminGatewayError>

Pays a BOLT12 offer using the gateway’s lightning node

pub async fn select_client( &self, federation_id: FederationId, ) -> Result<Spanned<Arc<ClientHandle>>, FederationNotConnected>

Retrieves a ClientHandleArc from the Gateway’s in memory structures that keep track of available clients, given a federation_id.

pub async fn get_lightning_context( &self, ) -> Result<LightningContext, LightningRpcError>

Checks the Gateway’s current state and returns the proper LightningContext if it is available. Sometimes the lightning node will not be connected and this will return an error.

pub async fn unannounce_from_all_federations(&self)

Iterates through all of the federations the gateway is registered with and requests to remove the registration record.

impl Gateway

pub async fn routing_info_v2( &self, federation_id: &FederationId, ) -> Result<Option<RoutingInfo>, PublicGatewayError>

Returns payment information that LNv2 clients can use to instruct this Gateway to pay an invoice or receive a payment.

pub async fn create_invoice_via_lnrpc_v2( &self, payment_hash: Hash, amount: Amount, description: Bolt11InvoiceDescription, expiry_time: u32, ) -> Result<Bolt11Invoice, LightningRpcError>

Retrieves a BOLT11 invoice from the connected Lightning node with a specific payment_hash.

pub async fn verify_bolt11_preimage_v2( &self, payment_hash: Hash, wait: bool, ) -> Result<VerifyResponse, String>

pub async fn get_registered_incoming_contract_and_client_v2( &self, payment_image: PaymentImage, amount_msats: u64, ) -> Result<(IncomingContract, Arc<ClientHandle>), PublicGatewayError>

Retrieves the persisted CreateInvoicePayload from the database specified by the payment_hash and the ClientHandleArc specified by the payload’s federation_id.

Trait Implementations

impl Clone for Gateway

fn clone(&self) -> Gateway

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Gateway

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

Formats the value using the given formatter.

impl IGatewayClientV1 for Gateway

fn verify_preimage_authentication<'life0, 'async_trait>( &'life0 self, payment_hash: Hash, preimage_auth: Hash, contract: OutgoingContractAccount, ) -> Pin<Box<dyn Future<Output = Result<(), OutgoingPaymentError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Verifies that the supplied preimage_auth is the same as the preimage_auth that initiated the payment.

fn verify_pruned_invoice<'life0, 'async_trait>( &'life0 self, payment_data: PaymentData, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Verify that the lightning node supports private payments if a pruned invoice is supplied.

fn get_routing_fees<'life0, 'async_trait>( &'life0 self, federation_id: FederationId, ) -> Pin<Box<dyn Future<Output = Option<RoutingFees>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Retrieves the federation’s routing fees from the federation’s config.

fn get_client<'life0, 'life1, 'async_trait>( &'life0 self, federation_id: &'life1 FederationId, ) -> Pin<Box<dyn Future<Output = Option<Spanned<Arc<ClientHandle>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Gateway: 'async_trait,

Retrieve a client given a federation ID, used for swapping ecash between federations.

fn get_client_for_invoice<'life0, 'async_trait>( &'life0 self, payment_data: PaymentData, ) -> Pin<Box<dyn Future<Output = Option<Spanned<Arc<ClientHandle>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

fn pay<'life0, 'async_trait>( &'life0 self, payment_data: PaymentData, max_delay: u64, max_fee: Amount, ) -> Pin<Box<dyn Future<Output = Result<PayInvoiceResponse, LightningRpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Pay a Lightning invoice using the gateway’s lightning node.

fn complete_htlc<'life0, 'async_trait>( &'life0 self, htlc: InterceptPaymentResponse, ) -> Pin<Box<dyn Future<Output = Result<(), LightningRpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Use the gateway’s lightning node to send a complete HTLC response.

fn is_lnv2_direct_swap<'life0, 'async_trait>( &'life0 self, payment_hash: Hash, amount: Amount, ) -> Pin<Box<dyn Future<Output = Result<Option<(IncomingContract, Arc<ClientHandle>)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Check if the gateway satisfy the LNv1 payment by funding an LNv2 IncomingContract

impl IGatewayClientV2 for Gateway

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

where 'life0: 'async_trait, Gateway: 'async_trait,

Use the gateway’s lightning node to complete a payment

fn is_direct_swap<'life0, 'life1, 'async_trait>( &'life0 self, invoice: &'life1 Bolt11Invoice, ) -> Pin<Box<dyn Future<Output = Result<Option<(IncomingContract, Arc<ClientHandle>)>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Gateway: 'async_trait,

Determines if the payment can be completed using a direct swap to another federation.

fn pay<'life0, 'async_trait>( &'life0 self, invoice: Bolt11Invoice, max_delay: u64, max_fee: Amount, ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], LightningRpcError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Gateway: 'async_trait,

Initiates a payment over the Lightning network.

fn min_contract_amount<'life0, 'life1, 'async_trait>( &'life0 self, federation_id: &'life1 FederationId, amount: u64, ) -> Pin<Box<dyn Future<Output = Result<Amount, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Gateway: 'async_trait,

Computes the minimum contract amount necessary for making an outgoing payment.

fn is_lnv1_invoice<'life0, 'life1, 'async_trait>( &'life0 self, invoice: &'life1 Bolt11Invoice, ) -> Pin<Box<dyn Future<Output = Option<Spanned<Arc<ClientHandle>>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Gateway: 'async_trait,

Check if this invoice was created using LNv1 and if the gateway is connected to the target federation.

fn relay_lnv1_swap<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, client: &'life1 Arc<ClientHandle>, invoice: &'life2 Bolt11Invoice, ) -> Pin<Box<dyn Future<Output = Result<FinalReceiveState, Error>> + Send + 'async_trait>>

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

Perform a swap from an LNv2 OutgoingContract to an LNv1 IncomingContract