Function call_rpc_method

plugins/rest-plugin/src/handlers.rs:228–292

(
    http_method: http::Method,
    Path(path): Path<String>,
    headers: axum::http::HeaderMap,
    Extension(plugin): Extension<Plugin<PluginState>>,
    body: Request<Body>,
)

    security(("api_key" = []))
)]
pub async fn call_rpc_method(
    http_method: http::Method,
    Path(path): Path<String>,
    headers: axum::http::HeaderMap,
    Extension(plugin): Extension<Plugin<PluginState>>,
    body: Request<Body>,
) -> Result<Response, AppError> {
    let rune = headers
        .get("rune")
        .and_then(|v| v.to_str().ok())
        .map(String::from);

    let request_bytes = match to_bytes(body.into_body(), MAX_BODY_SIZE).await {
        Ok(o) => o,
        Err(e) => {
            if is_body_too_large(&e) {
                return Err(AppError::PayloadTooLarge(RpcError {
                    code: Some(-32600),
                    data: None,
                    message: format!(
                        "Request body exceeds the maximum allowed size of {MAX_BODY_SIZE} bytes"
                    ),
                }));
            }
            return Err(AppError::InternalServerError(RpcError {
                code: Some(-32700),
                data: None,
                message: format!("Could not read request body: {}", e),
            }));
        }
    };

    let (mut rest_map, mut rpc_params) = path_to_rest_map_and_params(&plugin, &path, &http_method)?;

    request_body_to_rpc_params(
        &mut rpc_params,
        &headers,
        &rest_map.rpc_method,
        request_bytes,
    )?;

    fill_rune_restrictions(&mut rest_map, &rpc_params);

    let mut rpc_params_value = json!(rpc_params);

    filter_json(&mut rpc_params_value);

    if rest_map.rune_required || http_method != http::Method::GET {
        verify_rune(&plugin, rune, &rest_map.rune_restrictions.unwrap()).await?;
    }

    let cln_result = match call_rpc(&plugin, &rest_map.rpc_method, rpc_params_value).await {
        Ok(result) => result,
        Err(err) => {
            if let Some(code) = err.code {
                if code == -32601 {
                    return Err(AppError::NotFound(err));
                }