kora-lib 2.0.5

Core library for Kora gasless relayer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{
    config::{EnabledMethods, FeePayerPolicy, ValidationConfig},
    fee::price::{PriceConfig, PriceModel},
    oracle::oracle::{PriceSource, TokenPrice},
};
use std::path::PathBuf;
use utoipa::{
    openapi::{
        path::OperationBuilder, request_body::RequestBodyBuilder, ContentBuilder, PathItem,
        PathItemType, Required, ResponseBuilder, ResponsesBuilder, ServerBuilder,
    },
    OpenApi,
};

use crate::rpc_server::{
    method::{
        get_blockhash::GetBlockhashResponse,
        get_config::GetConfigResponse,
        get_payer_signer::GetPayerSignerResponse,
        get_supported_tokens::GetSupportedTokensResponse,
        sign_and_send_transaction::{
            SignAndSendTransactionRequest, SignAndSendTransactionResponse,
        },
        sign_transaction::{SignTransactionRequest, SignTransactionResponse},
        transfer_transaction::{TransferTransactionRequest, TransferTransactionResponse},
    },
    KoraRpc,
};

use super::helper::{build_error_response, request_schema};

const JSON_CONTENT_TYPE: &str = "application/json";

#[derive(OpenApi)]
#[openapi(
    info(
        title = "kora-rpc",
        version = "0.1.0",
        description = "RPC server for Kora gasless relayer",
        license(name = "MIT")
    ),
    components(schemas(
        ValidationConfig,
        FeePayerPolicy,
        EnabledMethods,
        PriceConfig,
        PriceModel,
        TokenPrice,
        PriceSource,
        GetBlockhashResponse,
        GetConfigResponse,
        GetPayerSignerResponse,
        GetSupportedTokensResponse,
        SignAndSendTransactionRequest,
        SignAndSendTransactionResponse,
        SignTransactionRequest,
        SignTransactionResponse,
        TransferTransactionRequest,
        TransferTransactionResponse,
    ))
)]
pub struct ApiDoc;

pub fn update_docs() {
    let method_specs = KoraRpc::build_docs_spec();
    let mut combined_doc = ApiDoc::openapi();

    // Get base components
    let components = combined_doc.components.unwrap_or_default();

    combined_doc.servers =
        Some(vec![ServerBuilder::new().url("https://api.example.com/v1".to_string()).build()]);

    for spec in method_specs {
        let content =
            ContentBuilder::new().schema(request_schema(&spec.name, spec.request.clone())).build();

        let request_body = RequestBodyBuilder::new()
            .content(JSON_CONTENT_TYPE, content)
            .required(Some(Required::True))
            .build();

        let responses = ResponsesBuilder::new()
            .response(
                "200",
                ResponseBuilder::new().description("Successful response").content(
                    JSON_CONTENT_TYPE,
                    ContentBuilder::new().schema(spec.response.clone()).build(),
                ),
            )
            .response("429", build_error_response("Exceeded rate limit."))
            .response("500", build_error_response("Internal server error."))
            .build();

        let operation =
            OperationBuilder::new().request_body(Some(request_body)).responses(responses).build();

        let mut path_item = PathItem::new(PathItemType::Post, operation);
        path_item.summary = Some(spec.name.clone());

        combined_doc.paths.paths.insert(format!("/{}", spec.name), path_item);
    }

    // Set the components
    combined_doc.components = Some(components);

    let json = serde_json::to_string_pretty(&combined_doc).unwrap();
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("src/rpc_server/openapi/spec/combined_api.json");

    // Create parent directory if it doesn't exist
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent).unwrap();
    }

    std::fs::write(&path, json).unwrap();

    let validate_result = std::process::Command::new("npx")
        .arg("@redocly/cli@latest")
        .arg("lint")
        .arg("--extends=minimal")
        .arg(path.to_str().unwrap())
        .output()
        .unwrap();

    if !validate_result.status.success() {
        let stderr = String::from_utf8_lossy(&validate_result.stderr);
        panic!("Failed to validate OpenAPI schema: {stderr}");
    }
}