Struct gl_client :: signer :: model :: cln :: node_client :: NodeClient Copy item path

impl NodeClient<Channel>

pub async fn connect<D>(dst: D) -> Result<NodeClient<Channel>, Error>
where D: TryInto<Endpoint>, <D as TryInto<Endpoint>>::Error: Into<Box<dyn Error + Sync + Send>>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> NodeClient<T>
where T: GrpcService<UnsyncBoxBody<Bytes, Status>>, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::Error: Into<Box<dyn Error + Sync + Send>>, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody: Body<Data = Bytes> + Send + 'static, <<T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody as Body>::Error: Into<Box<dyn Error + Sync + Send>> + Send,

pub fn new(inner: T) -> NodeClient<T>

pub fn with_origin(inner: T, origin: Uri) -> NodeClient<T>

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> NodeClient<InterceptedService<T, F>>
where F: Interceptor, <T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody: Default, T: Service<Request<UnsyncBoxBody<Bytes, Status>>, Response = Response<<T as GrpcService<UnsyncBoxBody<Bytes, Status>>>::ResponseBody>>, <T as Service<Request<UnsyncBoxBody<Bytes, Status>>>>::Error: Into<Box<dyn Error + Sync + Send>> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> NodeClient<T>

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> NodeClient<T>

Enable decompressing responses.

pub async fn getinfo( &mut self, request: impl IntoRequest<GetinfoRequest>, ) -> Result<Response<GetinfoResponse>, Status>

pub async fn list_peers( &mut self, request: impl IntoRequest<ListpeersRequest>, ) -> Result<Response<ListpeersResponse>, Status>

pub async fn list_funds( &mut self, request: impl IntoRequest<ListfundsRequest>, ) -> Result<Response<ListfundsResponse>, Status>

pub async fn send_pay( &mut self, request: impl IntoRequest<SendpayRequest>, ) -> Result<Response<SendpayResponse>, Status>

pub async fn list_channels( &mut self, request: impl IntoRequest<ListchannelsRequest>, ) -> Result<Response<ListchannelsResponse>, Status>

pub async fn add_gossip( &mut self, request: impl IntoRequest<AddgossipRequest>, ) -> Result<Response<AddgossipResponse>, Status>

pub async fn auto_clean_invoice( &mut self, request: impl IntoRequest<AutocleaninvoiceRequest>, ) -> Result<Response<AutocleaninvoiceResponse>, Status>

pub async fn check_message( &mut self, request: impl IntoRequest<CheckmessageRequest>, ) -> Result<Response<CheckmessageResponse>, Status>

pub async fn close( &mut self, request: impl IntoRequest<CloseRequest>, ) -> Result<Response<CloseResponse>, Status>

pub async fn connect_peer( &mut self, request: impl IntoRequest<ConnectRequest>, ) -> Result<Response<ConnectResponse>, Status>

pub async fn create_invoice( &mut self, request: impl IntoRequest<CreateinvoiceRequest>, ) -> Result<Response<CreateinvoiceResponse>, Status>

pub async fn datastore( &mut self, request: impl IntoRequest<DatastoreRequest>, ) -> Result<Response<DatastoreResponse>, Status>

pub async fn datastore_usage( &mut self, request: impl IntoRequest<DatastoreusageRequest>, ) -> Result<Response<DatastoreusageResponse>, Status>

pub async fn create_onion( &mut self, request: impl IntoRequest<CreateonionRequest>, ) -> Result<Response<CreateonionResponse>, Status>

pub async fn del_datastore( &mut self, request: impl IntoRequest<DeldatastoreRequest>, ) -> Result<Response<DeldatastoreResponse>, Status>

pub async fn del_expired_invoice( &mut self, request: impl IntoRequest<DelexpiredinvoiceRequest>, ) -> Result<Response<DelexpiredinvoiceResponse>, Status>

pub async fn del_invoice( &mut self, request: impl IntoRequest<DelinvoiceRequest>, ) -> Result<Response<DelinvoiceResponse>, Status>

pub async fn invoice( &mut self, request: impl IntoRequest<InvoiceRequest>, ) -> Result<Response<InvoiceResponse>, Status>

pub async fn list_datastore( &mut self, request: impl IntoRequest<ListdatastoreRequest>, ) -> Result<Response<ListdatastoreResponse>, Status>

pub async fn list_invoices( &mut self, request: impl IntoRequest<ListinvoicesRequest>, ) -> Result<Response<ListinvoicesResponse>, Status>

pub async fn send_onion( &mut self, request: impl IntoRequest<SendonionRequest>, ) -> Result<Response<SendonionResponse>, Status>

pub async fn list_send_pays( &mut self, request: impl IntoRequest<ListsendpaysRequest>, ) -> Result<Response<ListsendpaysResponse>, Status>

pub async fn list_transactions( &mut self, request: impl IntoRequest<ListtransactionsRequest>, ) -> Result<Response<ListtransactionsResponse>, Status>

pub async fn pay( &mut self, request: impl IntoRequest<PayRequest>, ) -> Result<Response<PayResponse>, Status>

pub async fn list_nodes( &mut self, request: impl IntoRequest<ListnodesRequest>, ) -> Result<Response<ListnodesResponse>, Status>

pub async fn wait_any_invoice( &mut self, request: impl IntoRequest<WaitanyinvoiceRequest>, ) -> Result<Response<WaitanyinvoiceResponse>, Status>

pub async fn wait_invoice( &mut self, request: impl IntoRequest<WaitinvoiceRequest>, ) -> Result<Response<WaitinvoiceResponse>, Status>

pub async fn wait_send_pay( &mut self, request: impl IntoRequest<WaitsendpayRequest>, ) -> Result<Response<WaitsendpayResponse>, Status>

pub async fn new_addr( &mut self, request: impl IntoRequest<NewaddrRequest>, ) -> Result<Response<NewaddrResponse>, Status>

pub async fn withdraw( &mut self, request: impl IntoRequest<WithdrawRequest>, ) -> Result<Response<WithdrawResponse>, Status>

pub async fn key_send( &mut self, request: impl IntoRequest<KeysendRequest>, ) -> Result<Response<KeysendResponse>, Status>

pub async fn fund_psbt( &mut self, request: impl IntoRequest<FundpsbtRequest>, ) -> Result<Response<FundpsbtResponse>, Status>

pub async fn send_psbt( &mut self, request: impl IntoRequest<SendpsbtRequest>, ) -> Result<Response<SendpsbtResponse>, Status>

pub async fn sign_psbt( &mut self, request: impl IntoRequest<SignpsbtRequest>, ) -> Result<Response<SignpsbtResponse>, Status>

pub async fn utxo_psbt( &mut self, request: impl IntoRequest<UtxopsbtRequest>, ) -> Result<Response<UtxopsbtResponse>, Status>

pub async fn tx_discard( &mut self, request: impl IntoRequest<TxdiscardRequest>, ) -> Result<Response<TxdiscardResponse>, Status>

pub async fn tx_prepare( &mut self, request: impl IntoRequest<TxprepareRequest>, ) -> Result<Response<TxprepareResponse>, Status>

pub async fn tx_send( &mut self, request: impl IntoRequest<TxsendRequest>, ) -> Result<Response<TxsendResponse>, Status>

pub async fn list_peer_channels( &mut self, request: impl IntoRequest<ListpeerchannelsRequest>, ) -> Result<Response<ListpeerchannelsResponse>, Status>

pub async fn list_closed_channels( &mut self, request: impl IntoRequest<ListclosedchannelsRequest>, ) -> Result<Response<ListclosedchannelsResponse>, Status>

pub async fn decode_pay( &mut self, request: impl IntoRequest<DecodepayRequest>, ) -> Result<Response<DecodepayResponse>, Status>

pub async fn decode( &mut self, request: impl IntoRequest<DecodeRequest>, ) -> Result<Response<DecodeResponse>, Status>

pub async fn disconnect( &mut self, request: impl IntoRequest<DisconnectRequest>, ) -> Result<Response<DisconnectResponse>, Status>

pub async fn feerates( &mut self, request: impl IntoRequest<FeeratesRequest>, ) -> Result<Response<FeeratesResponse>, Status>

pub async fn fetch_invoice( &mut self, request: impl IntoRequest<FetchinvoiceRequest>, ) -> Result<Response<FetchinvoiceResponse>, Status>

pub async fn fund_channel( &mut self, request: impl IntoRequest<FundchannelRequest>, ) -> Result<Response<FundchannelResponse>, Status>

pub async fn get_route( &mut self, request: impl IntoRequest<GetrouteRequest>, ) -> Result<Response<GetrouteResponse>, Status>

pub async fn list_forwards( &mut self, request: impl IntoRequest<ListforwardsRequest>, ) -> Result<Response<ListforwardsResponse>, Status>

pub async fn list_offers( &mut self, request: impl IntoRequest<ListoffersRequest>, ) -> Result<Response<ListoffersResponse>, Status>

pub async fn list_pays( &mut self, request: impl IntoRequest<ListpaysRequest>, ) -> Result<Response<ListpaysResponse>, Status>

pub async fn list_htlcs( &mut self, request: impl IntoRequest<ListhtlcsRequest>, ) -> Result<Response<ListhtlcsResponse>, Status>

pub async fn offer( &mut self, request: impl IntoRequest<OfferRequest>, ) -> Result<Response<OfferResponse>, Status>

pub async fn ping( &mut self, request: impl IntoRequest<PingRequest>, ) -> Result<Response<PingResponse>, Status>

pub async fn send_custom_msg( &mut self, request: impl IntoRequest<SendcustommsgRequest>, ) -> Result<Response<SendcustommsgResponse>, Status>

pub async fn set_channel( &mut self, request: impl IntoRequest<SetchannelRequest>, ) -> Result<Response<SetchannelResponse>, Status>

pub async fn sign_invoice( &mut self, request: impl IntoRequest<SigninvoiceRequest>, ) -> Result<Response<SigninvoiceResponse>, Status>

pub async fn sign_message( &mut self, request: impl IntoRequest<SignmessageRequest>, ) -> Result<Response<SignmessageResponse>, Status>

pub async fn wait_block_height( &mut self, request: impl IntoRequest<WaitblockheightRequest>, ) -> Result<Response<WaitblockheightResponse>, Status>

pub async fn wait( &mut self, request: impl IntoRequest<WaitRequest>, ) -> Result<Response<WaitResponse>, Status>

pub async fn stop( &mut self, request: impl IntoRequest<StopRequest>, ) -> Result<Response<StopResponse>, Status>

pub async fn pre_approve_keysend( &mut self, request: impl IntoRequest<PreapprovekeysendRequest>, ) -> Result<Response<PreapprovekeysendResponse>, Status>

pub async fn pre_approve_invoice( &mut self, request: impl IntoRequest<PreapproveinvoiceRequest>, ) -> Result<Response<PreapproveinvoiceResponse>, Status>

pub async fn static_backup( &mut self, request: impl IntoRequest<StaticbackupRequest>, ) -> Result<Response<StaticbackupResponse>, Status>

pub async fn bkpr_list_income( &mut self, request: impl IntoRequest<BkprlistincomeRequest>, ) -> Result<Response<BkprlistincomeResponse>, Status>

Trait Implementations§

impl<T> Clone for NodeClient<T>
where T: Clone,

fn clone(&self) -> NodeClient<T>

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<T> Debug for NodeClient<T>
where T: Debug,

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

impl<T> UnwindSafe for NodeClient<T>
where T: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Any for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

fn type_name(&self) -> &'static str

impl<T> AnySync for T
where T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

impl<T> AsAny for T
where T: Any,

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

fn type_name(&self) -> &'static str

Gets the type name of self

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Downcast for T
where T: AsAny + ?Sized,

fn is<T>(&self) -> bool
where T: AsAny,

Returns true if the boxed type is the same as T. Read more

fn downcast_ref<T>(&self) -> Option<&T>
where T: AsAny,

Forward to the method defined on the type Any.

fn downcast_mut<T>(&mut self) -> Option<&mut T>
where T: AsAny,

Forward to the method defined on the type Any.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FromRef<T> for T
where T: Clone,

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> IntoRequest<T> for T

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request

impl<T> Same for T

type Output = T

Should always be Self

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more