Struct Builder 

pub struct Builder<S, I, O>
where
    I: AsyncRead + Unpin,
    O: Send + AsyncWrite + Unpin,
    S: Clone + Send,
{ /* private fields */ }

Builder for a new plugin.

Implementations

impl<S, I, O> Builder<S, I, O>

where O: Send + AsyncWrite + Unpin + 'static, S: Clone + Sync + Send + 'static, I: AsyncRead + Send + Unpin + 'static,

pub fn new(input: I, output: O) -> Self

pub fn option<'a, V: OptionType<'a>>( self, opt: ConfigOption<'a, V>, ) -> Builder<S, I, O>

pub fn notification(self, notif: NotificationTopic) -> Builder<S, I, O>

pub fn subscribe<C, F>(self, topic: &str, callback: C) -> Builder<S, I, O>

where C: Send + Sync + 'static + Fn(Plugin<S>, Value) -> F, F: Future<Output = Result<(), Error>> + Send + 'static,

Subscribe to notifications for the given topic. The handler is an async function that takes a Plugin<S> and the notification as a serde_json::Value as inputs. Since notifications do not expect a result the handler should only report errors while processing. Any error reported while processing the notification will be logged in the cln logs.

use cln_plugin::{options, Builder, Error, Plugin};

async fn connect_handler(_p: Plugin<()>, v: serde_json::Value) -> Result<(), Error> {
    println!("Got a connect notification: {}", v);
    Ok(())
}

let b = Builder::new(tokio::io::stdin(), tokio::io::stdout())
    .subscribe("connect", connect_handler);

pub fn hook<C, F>(self, hookname: &str, callback: C) -> Self

where C: Send + Sync + 'static + Fn(Plugin<S>, Value) -> F, F: Future<Output = Result<Value, Error>> + Send + 'static,

Add a hook subscription for hookname with a raw serde_json::Value request and response. Prefer Builder::hook_typed for type-safe hooks, or Builder::hook_from_builder if you need to configure before, after, or filters.

pub fn hook_from_builder(self, hook: HookBuilder<S>) -> Builder<S, I, O>

Add a hook subscription using a HookBuilder, which allows configuring before, after, and filters in addition to the callback. Use HookBuilder::new for raw serde_json::Value hooks or HookBuilder::new_typed for type-safe hooks.

pub fn hook_typed<C, F, Req, Resp>(self, hookname: &str, callback: C) -> Self

where C: Send + Sync + 'static + Fn(Plugin<S>, Req) -> F, F: Future<Output = Result<Resp, Error>> + Send + 'static, Req: DeserializeOwned + Send + 'static, Resp: Serialize + Send + 'static,

Add a hook subscription for hookname with typed request and response. The request is deserialized from JSON into Req and the response is serialized from Resp back to JSON automatically. If deserialization of the request fails, the hook returns an error to CLN. Use Builder::hook_from_builder with HookBuilder::new_typed if you additionally need to configure before, after, or filters.

pub fn rpcmethod<C, F>( self, name: &str, description: &str, callback: C, ) -> Builder<S, I, O>

where C: Send + Sync + 'static + Fn(Plugin<S>, Value) -> F, F: Future<Output = Result<Value, Error>> + Send + 'static,

Register a custom RPC method for the RPC passthrough from the main daemon

pub fn rpcmethod_from_builder( self, rpc_method: RpcMethodBuilder<S>, ) -> Builder<S, I, O>

pub fn setconfig_callback<C, F>(self, setconfig_callback: C) -> Builder<S, I, O>

where C: Send + Sync + 'static + Fn(Plugin<S>, Value) -> F, F: Future<Output = Result<Value, Error>> + Send + 'static,

Register a callback for setconfig to accept changes for dynamic options

pub fn dynamic(self) -> Builder<S, I, O>

Send true value for “dynamic” field in “getmanifest” response

pub fn featurebits(self, kind: FeatureBitsKind, hex: String) -> Self

Sets the “featurebits” in the “getmanifest” response

pub fn with_logging(self, log: bool) -> Builder<S, I, O>

Should the plugin automatically register a logging handler? If not you may need to register a logging handler yourself. Be careful not to print raw lines to stdout if you do, since that’ll interfere with the plugin communication. See the CLN documentation on logging to see what logging events should look like.

pub fn custommessages(self, custommessages: Vec<u16>) -> Self

Tells lightningd explicitly to allow custommmessages of the provided type

pub async fn configure(self) -> Result<Option<ConfiguredPlugin<S, I, O>>, Error>

Communicate with lightningd to tell it about our options, RPC methods and subscribe to hooks, and then process the initialization, configuring the plugin.

Returns None if we were invoked with --help and thus should exit after this handshake

pub async fn start(self, state: S) -> Result<Option<Plugin<S>>, Error>

Build and start the plugin loop. This performs the handshake and spawns a new task that accepts incoming messages from Core Lightning and dispatches them to the handlers. It only returns after completing the handshake to ensure that the configuration and initialization was successfull.

If lightningd was called with --help we won’t get a Plugin instance and return None instead. This signals that we should exit, and not continue running. start() returns in order to allow user code to perform cleanup if necessary.