Method call

cln-rpc/src/lib.rs:60–108

(&mut self, req: Request)

    }

    pub async fn call(&mut self, req: Request) -> Result<Response, RpcError> {
        trace!("Sending request {:?}", req);

        // Wrap the raw request in a well-formed JSON-RPC outer dict.
        let id = self.next_id.fetch_add(1, Ordering::SeqCst);
        let req: JsonRpc<Notification, Request> = JsonRpc::Request(json!(id), req);
        let req = serde_json::to_value(req).map_err(|e| RpcError {
            code: None,
            message: format!("Error parsing request: {}", e),
        })?;
        let req2 = req.clone();
        self.write.send(req).await.map_err(|e| RpcError {
            code: None,
            message: format!("Error passing request to lightningd: {}", e),
        })?;

        let mut response = self
            .read
            .next()
            .await
            .ok_or_else(|| RpcError {
                code: None,
                message: "no response from lightningd".to_string(),
            })?
            .map_err(|_| RpcError {
                code: None,
                message: "reading response from socket".to_string(),
            })?;
        trace!("Read response {:?}", response);

        // Annotate the response with the method from the request, so
        // serde_json knows which variant of [`Request`] should be
        // used.
        response["method"] = req2["method"].clone();
        if let Some(_) = response.get("result") {
            serde_json::from_value(response).map_err(|e| RpcError {
                code: None,
                message: format!("Malformed response from lightningd: {}", e),
            })
        } else if let Some(e) = response.get("error") {
            let e: RpcError = serde_json::from_value(e.clone()).unwrap();
            Err(e)
        } else {
            Err(RpcError {
                code: None,
                message: format!("Malformed response from lightningd: {}", response),
            })
        }
    }

    pub async fn call_typed<R: IntoRequest>(&mut self, request: R) -> Result<R::Response, RpcError> {
        Ok(self.call(request.into())