sui_config/
rpc_config.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use std::net::SocketAddr;
5use std::time::Duration;
6
7#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
8#[serde(rename_all = "kebab-case")]
9pub struct RpcConfig {
10    /// Enable indexing of transactions and objects
11    ///
12    /// This enables indexing of transactions and objects which allows for a slightly richer rpc
13    /// api. There are some APIs which will be disabled/enabled based on this config while others
14    /// (eg GetTransaction) will still be enabled regardless of this config but may return slight
15    /// less data (eg GetTransaction won't return the checkpoint that includes the requested
16    /// transaction).
17    ///
18    /// Defaults to `false`, with indexing and APIs which require indexes being disabled
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub enable_indexing: Option<bool>,
21
22    /// Configure the address to listen on for https
23    ///
24    /// Defaults to `0.0.0.0:9443` if not specified.
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub https_address: Option<SocketAddr>,
27
28    /// TLS configuration to use for https.
29    ///
30    /// If not provided then the node will not create an https service.
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub tls: Option<RpcTlsConfig>,
33
34    /// Maxumum budget for rendering a Move value into JSON.
35    ///
36    /// This sets the numbers of bytes that we are willing to spend on rendering field names and
37    /// values when rendering a Move value into a JSON value.
38    ///
39    /// Defaults to `1MiB` if not specified.
40    #[serde(skip_serializing_if = "Option::is_none")]
41    pub max_json_move_value_size: Option<usize>,
42
43    /// Aggregate budget for Move-value JSON rendering across a single response.
44    ///
45    /// Endpoints that render many Move values in one response (e.g. `GetCheckpoint`
46    /// with a `read_mask` that selects every event's `json` field) share this
47    /// budget across all per-item renders, so the response cannot multiply one
48    /// request into hundreds of MiB of materialized `prost_types::Value`.
49    ///
50    /// Defaults to `16 MiB` if not specified.
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub max_json_move_value_response_size: Option<usize>,
53
54    /// Configuration for RPC index initialization and bulk loading
55    #[serde(skip_serializing_if = "Option::is_none")]
56    pub index_initialization: Option<RpcIndexInitConfig>,
57
58    /// Tunables for the ledger-history list APIs (`list_transactions`,
59    /// `list_events`, `list_checkpoints`). These scan the historical inverted
60    /// indexes, unlike the live object-set listings (`list_owned_objects`,
61    /// `list_dynamic_fields`), so they carry their own time and scan-cost bounds.
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub ledger_history: Option<LedgerHistoryConfig>,
64
65    /// Number of consecutive checkpoints a filtered subscription may go without
66    /// producing an item before the server emits a progress-only frame,
67    /// so sparse subscribers always learn their resume point. Defaults to 25
68    /// (~5 seconds at mainnet checkpoint cadence).
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub subscription_watermark_interval: Option<u32>,
71
72    /// Maximum number of concurrent RPC subscriptions. Defaults to 1024.
73    #[serde(skip_serializing_if = "Option::is_none")]
74    pub subscription_max_subscribers: Option<usize>,
75
76    /// Number of parallel shard tasks that evaluate subscription filters and
77    /// deliver updates. Each subscriber lives on one shard; per-checkpoint
78    /// filter evaluation parallelizes across shards. Defaults to the host's
79    /// available parallelism.
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub subscription_shards: Option<u32>,
82
83    /// Configuration for rendering Objects based on the Display standard
84    #[serde(skip_serializing_if = "Option::is_none")]
85    pub display: Option<DisplayConfig>,
86
87    /// Maximum age of an RPC connection, in seconds. When a connection
88    /// reaches this age the server sends GOAWAY and stops accepting new
89    /// streams on it; in-flight requests are allowed to complete within
90    /// `max-connection-age-grace-secs`. Bounding connection lifetime is the
91    /// server-side backstop that reclaims streams wedged behind HTTP/2
92    /// flow-control windows that a stalled peer never reopens.
93    ///
94    /// Defaults to 4 hours. Set to `0` to disable (connections then live
95    /// forever).
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub max_connection_age_secs: Option<u64>,
98
99    /// Grace period, in seconds, that in-flight requests are given to
100    /// complete after a connection begins shutting down (its
101    /// `max-connection-age-secs` expired, or the node is stopping). When
102    /// the grace period expires the connection is closed even if streams
103    /// are still open. Set to `0` to close immediately at shutdown.
104    ///
105    /// Defaults to 10 minutes. Has no effect while
106    /// `max-connection-age-secs` is disabled and the node is running.
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub max_connection_age_grace_secs: Option<u64>,
109
110    /// Server-side timeout for gRPC requests, in milliseconds. Requests
111    /// that carry a `grpc-timeout` header are bounded by the smaller of the
112    /// two values. The timeout covers a unary request's full execution and
113    /// a streaming request's time to first response; it does not bound the
114    /// lifetime of an established stream.
115    ///
116    /// Defaults to 60 seconds. Set to `0` to disable.
117    #[serde(skip_serializing_if = "Option::is_none")]
118    pub grpc_timeout_ms: Option<u64>,
119}
120
121const DEFAULT_MAX_CONNECTION_AGE: Duration = Duration::from_secs(4 * 60 * 60);
122const DEFAULT_MAX_CONNECTION_AGE_GRACE: Duration = Duration::from_secs(10 * 60);
123const DEFAULT_GRPC_TIMEOUT: Duration = Duration::from_secs(60);
124
125impl RpcConfig {
126    pub fn enable_indexing(&self) -> bool {
127        self.enable_indexing.unwrap_or(false)
128    }
129
130    pub fn https_address(&self) -> SocketAddr {
131        self.https_address
132            .unwrap_or_else(|| SocketAddr::from(([0, 0, 0, 0], 9443)))
133    }
134
135    pub fn tls_config(&self) -> Option<&RpcTlsConfig> {
136        self.tls.as_ref()
137    }
138
139    pub fn max_json_move_value_size(&self) -> usize {
140        self.max_json_move_value_size.unwrap_or(1024 * 1024)
141    }
142
143    pub fn max_json_move_value_response_size(&self) -> usize {
144        self.max_json_move_value_response_size
145            .unwrap_or(16 * 1024 * 1024)
146    }
147
148    pub fn index_initialization_config(&self) -> Option<&RpcIndexInitConfig> {
149        self.index_initialization.as_ref()
150    }
151
152    pub fn ledger_history(&self) -> &LedgerHistoryConfig {
153        const DEFAULT_LEDGER_HISTORY_CONFIG: LedgerHistoryConfig = LedgerHistoryConfig {
154            list_transactions: None,
155            list_events: None,
156            list_checkpoints: None,
157            bitmap_bucket_scan_budget: None,
158            chunk_bucket_scan_budget: None,
159            max_bitmap_filter_literals: None,
160        };
161
162        self.ledger_history
163            .as_ref()
164            .unwrap_or(&DEFAULT_LEDGER_HISTORY_CONFIG)
165    }
166
167    /// Maximum age of an RPC connection; `None` means unlimited.
168    pub fn max_connection_age(&self) -> Option<Duration> {
169        match self.max_connection_age_secs {
170            Some(0) => None,
171            Some(secs) => Some(Duration::from_secs(secs)),
172            None => Some(DEFAULT_MAX_CONNECTION_AGE),
173        }
174    }
175
176    /// Grace period for in-flight requests once a connection begins
177    /// shutting down; `Duration::ZERO` closes immediately.
178    pub fn max_connection_age_grace(&self) -> Duration {
179        self.max_connection_age_grace_secs
180            .map(Duration::from_secs)
181            .unwrap_or(DEFAULT_MAX_CONNECTION_AGE_GRACE)
182    }
183
184    /// Server-side default deadline for gRPC requests; `None` means no
185    /// server-imposed deadline (client `grpc-timeout` headers still apply).
186    pub fn grpc_timeout(&self) -> Option<Duration> {
187        match self.grpc_timeout_ms {
188            Some(0) => None,
189            Some(ms) => Some(Duration::from_millis(ms)),
190            None => Some(DEFAULT_GRPC_TIMEOUT),
191        }
192    }
193
194    /// Validate cross-field invariants. Call once at startup to fail fast on a
195    /// misconfiguration rather than surfacing it per-request.
196    pub fn validate(&self) -> anyhow::Result<()> {
197        self.ledger_history().validate()
198    }
199
200    pub fn display(&self) -> &DisplayConfig {
201        const DEFAULT_DISPLAY_CONFIG: DisplayConfig = DisplayConfig {
202            max_field_depth: None,
203            max_format_nodes: None,
204            max_object_loads: None,
205            max_move_value_depth: None,
206            max_output_size: None,
207        };
208
209        self.display.as_ref().unwrap_or(&DEFAULT_DISPLAY_CONFIG)
210    }
211}
212
213#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
214#[serde(rename_all = "kebab-case")]
215pub struct RpcTlsConfig {
216    /// File path to a PEM formatted TLS certificate chain
217    cert: String,
218    /// File path to a PEM formatted TLS private key
219    key: String,
220}
221
222impl RpcTlsConfig {
223    pub fn cert(&self) -> &str {
224        &self.cert
225    }
226
227    pub fn key(&self) -> &str {
228        &self.key
229    }
230}
231
232/// Configuration for RPC index initialization and bulk loading
233#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
234#[serde(rename_all = "kebab-case")]
235pub struct RpcIndexInitConfig {
236    /// Override for RocksDB's set_db_write_buffer_size during bulk indexing.
237    /// This is the total memory budget for all column families' memtables.
238    ///
239    /// Defaults to 90% of system RAM if not specified.
240    #[serde(skip_serializing_if = "Option::is_none")]
241    pub db_write_buffer_size: Option<usize>,
242
243    /// Override for each column family's write buffer size during bulk indexing.
244    ///
245    /// Defaults to 25% of system RAM divided by max_write_buffer_number if not specified.
246    #[serde(skip_serializing_if = "Option::is_none")]
247    pub cf_write_buffer_size: Option<usize>,
248
249    /// Override for the maximum number of write buffers per column family during bulk indexing.
250    /// This value is capped at 32 as an upper bound.
251    ///
252    /// Defaults to a dynamic value based on system RAM if not specified.
253    #[serde(skip_serializing_if = "Option::is_none")]
254    pub cf_max_write_buffer_number: Option<i32>,
255
256    /// Override for the number of background jobs during bulk indexing.
257    ///
258    /// Defaults to the number of CPU cores if not specified.
259    #[serde(skip_serializing_if = "Option::is_none")]
260    pub max_background_jobs: Option<i32>,
261
262    /// Override for the batch size limit during bulk indexing.
263    /// This controls how much data is accumulated in memory before flushing to disk.
264    ///
265    /// Defaults to half the write buffer size or 128MB, whichever is smaller.
266    #[serde(skip_serializing_if = "Option::is_none")]
267    pub batch_size_limit: Option<usize>,
268}
269
270#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
271#[serde(rename_all = "kebab-case")]
272pub struct DisplayConfig {
273    /// Maximum number of times the parser can recurse into nested structures. Depth does not
274    /// account for all nodes, only nodes that can be contained within themselves.
275    ///
276    /// Defaults to `32` if not specified.
277    #[serde(skip_serializing_if = "Option::is_none")]
278    max_field_depth: Option<usize>,
279
280    /// Maximum number of AST nodes that can be allocated during parsing. This counts all values
281    /// that are instances of AST types (but not, for example, `Vec<T>`).
282    ///
283    /// Defaults to `32768` if not specified.
284    #[serde(skip_serializing_if = "Option::is_none")]
285    max_format_nodes: Option<usize>,
286
287    /// Maximum number of objects that can be loaded during formatting.
288    ///
289    /// Defaults to `8` if not specified.
290    #[serde(skip_serializing_if = "Option::is_none")]
291    max_object_loads: Option<usize>,
292
293    /// Maximum depth to use when converting a rendered Display value to JSON.
294    ///
295    /// Defaults to `32` if not specified.
296    #[serde(skip_serializing_if = "Option::is_none")]
297    max_move_value_depth: Option<usize>,
298
299    /// Maxumum budget for rendering an object based on its Display template.
300    ///
301    /// This sets the numbers of bytes that we are willing to spend on rendering field names and
302    /// values when rendering an object based on its Display template.
303    ///
304    /// Defaults to `1MiB` if not specified.
305    #[serde(skip_serializing_if = "Option::is_none")]
306    max_output_size: Option<usize>,
307}
308
309impl DisplayConfig {
310    pub fn max_field_depth(&self) -> usize {
311        self.max_field_depth.unwrap_or(32)
312    }
313
314    pub fn max_format_nodes(&self) -> usize {
315        self.max_format_nodes.unwrap_or(32768)
316    }
317
318    pub fn max_object_loads(&self) -> usize {
319        self.max_object_loads.unwrap_or(8)
320    }
321
322    pub fn max_move_value_depth(&self) -> usize {
323        self.max_move_value_depth.unwrap_or(32)
324    }
325
326    pub fn max_output_size(&self) -> usize {
327        self.max_output_size.unwrap_or(1024 * 1024)
328    }
329}
330
331#[cfg(test)]
332mod connection_lifecycle_tests {
333    use super::*;
334
335    /// These defaults are availability-relevant: connection age plus grace
336    /// is the server-side backstop that reclaims streams wedged behind
337    /// HTTP/2 flow-control windows, and the gRPC deadline bounds requests
338    /// from clients that set none. Pin them so they cannot silently regress
339    /// to disabled.
340    #[test]
341    fn connection_lifecycle_defaults_are_enabled() {
342        let config = RpcConfig::default();
343        assert_eq!(
344            config.max_connection_age(),
345            Some(Duration::from_secs(4 * 60 * 60))
346        );
347        assert_eq!(
348            config.max_connection_age_grace(),
349            Duration::from_secs(10 * 60)
350        );
351        assert_eq!(config.grpc_timeout(), Some(Duration::from_secs(60)));
352    }
353
354    #[test]
355    fn zero_disables_age_and_timeout() {
356        let config = RpcConfig {
357            max_connection_age_secs: Some(0),
358            max_connection_age_grace_secs: Some(0),
359            grpc_timeout_ms: Some(0),
360            ..Default::default()
361        };
362        assert_eq!(config.max_connection_age(), None);
363        // A zero grace is a valid setting: close immediately at shutdown.
364        assert_eq!(config.max_connection_age_grace(), Duration::ZERO);
365        assert_eq!(config.grpc_timeout(), None);
366    }
367
368    #[test]
369    fn explicit_values_are_used() {
370        let config = RpcConfig {
371            max_connection_age_secs: Some(60),
372            max_connection_age_grace_secs: Some(5),
373            grpc_timeout_ms: Some(1_500),
374            ..Default::default()
375        };
376        assert_eq!(config.max_connection_age(), Some(Duration::from_secs(60)));
377        assert_eq!(config.max_connection_age_grace(), Duration::from_secs(5));
378        assert_eq!(config.grpc_timeout(), Some(Duration::from_millis(1_500)));
379    }
380}
381
382const DEFAULT_LEDGER_HISTORY_METHOD_TIMEOUT_MS: u64 = 5_000;
383const DEFAULT_BITMAP_BUCKET_SCAN_BUDGET: usize = 1_024;
384const DEFAULT_CHUNK_BUCKET_SCAN_BUDGET: usize = 256;
385const DEFAULT_MAX_BITMAP_FILTER_LITERALS: usize = 10;
386// A chunk never evaluates more buckets than the whole request is allowed, so the
387// per-chunk cap must not exceed the per-request budget. Enforced for the
388// defaults here; the accessors clamp configured values the same way.
389const _: () = assert!(DEFAULT_CHUNK_BUCKET_SCAN_BUDGET <= DEFAULT_BITMAP_BUCKET_SCAN_BUDGET);
390
391/// Built-in per-endpoint defaults. These differ per endpoint (e.g. checkpoints
392/// page smaller than transactions, and scan a narrower chunk).
393struct LedgerHistoryMethodDefaults {
394    default_limit_items: u32,
395    max_limit_items: u32,
396    chunk_max: usize,
397}
398
399const LIST_TRANSACTIONS_DEFAULTS: LedgerHistoryMethodDefaults = LedgerHistoryMethodDefaults {
400    default_limit_items: 50,
401    max_limit_items: 500,
402    chunk_max: 32,
403};
404const LIST_EVENTS_DEFAULTS: LedgerHistoryMethodDefaults = LedgerHistoryMethodDefaults {
405    default_limit_items: 50,
406    max_limit_items: 1_000,
407    chunk_max: 32,
408};
409const LIST_CHECKPOINTS_DEFAULTS: LedgerHistoryMethodDefaults = LedgerHistoryMethodDefaults {
410    default_limit_items: 10,
411    max_limit_items: 50,
412    chunk_max: 16,
413};
414
415/// Per-endpoint tunables for one ledger-history list API. Every field is optional
416/// and falls back to a built-in default; see [`ResolvedLedgerHistoryMethodConfig`].
417#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
418#[serde(rename_all = "kebab-case")]
419pub struct LedgerHistoryMethodConfig {
420    /// Per-request wall-clock timeout, in milliseconds. Defaults to `5000`.
421    #[serde(skip_serializing_if = "Option::is_none")]
422    pub timeout_ms: Option<u64>,
423
424    /// Page size used when a request omits `limit_items`.
425    #[serde(skip_serializing_if = "Option::is_none")]
426    pub default_limit_items: Option<u32>,
427
428    /// Upper bound a request's `limit_items` is clamped to.
429    #[serde(skip_serializing_if = "Option::is_none")]
430    pub max_limit_items: Option<u32>,
431
432    /// Maximum items materialized per internal scan chunk.
433    #[serde(skip_serializing_if = "Option::is_none")]
434    pub chunk_max: Option<usize>,
435}
436
437/// A [`LedgerHistoryMethodConfig`] with all defaults applied.
438#[derive(Clone, Copy, Debug)]
439pub struct ResolvedLedgerHistoryMethodConfig {
440    pub timeout: Duration,
441    pub default_limit_items: u32,
442    pub max_limit_items: u32,
443    pub chunk_max: usize,
444}
445
446impl LedgerHistoryMethodConfig {
447    fn resolve(
448        this: Option<&LedgerHistoryMethodConfig>,
449        defaults: LedgerHistoryMethodDefaults,
450    ) -> ResolvedLedgerHistoryMethodConfig {
451        ResolvedLedgerHistoryMethodConfig {
452            timeout: Duration::from_millis(
453                this.and_then(|c| c.timeout_ms)
454                    .unwrap_or(DEFAULT_LEDGER_HISTORY_METHOD_TIMEOUT_MS),
455            ),
456            default_limit_items: this
457                .and_then(|c| c.default_limit_items)
458                .unwrap_or(defaults.default_limit_items),
459            max_limit_items: this
460                .and_then(|c| c.max_limit_items)
461                .unwrap_or(defaults.max_limit_items),
462            chunk_max: this.and_then(|c| c.chunk_max).unwrap_or(defaults.chunk_max),
463        }
464    }
465}
466
467/// Tunables for the ledger-history list APIs. Per-endpoint knobs live in
468/// the three [`LedgerHistoryMethodConfig`] fields; the remaining knobs are global across
469/// all three. Every field is optional and falls back to a built-in default.
470#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
471#[serde(rename_all = "kebab-case")]
472pub struct LedgerHistoryConfig {
473    /// Per-endpoint tunables for `list_transactions`.
474    #[serde(skip_serializing_if = "Option::is_none")]
475    pub list_transactions: Option<LedgerHistoryMethodConfig>,
476
477    /// Per-endpoint tunables for `list_events`.
478    #[serde(skip_serializing_if = "Option::is_none")]
479    pub list_events: Option<LedgerHistoryMethodConfig>,
480
481    /// Per-endpoint tunables for `list_checkpoints`.
482    #[serde(skip_serializing_if = "Option::is_none")]
483    pub list_checkpoints: Option<LedgerHistoryMethodConfig>,
484
485    /// Total evaluated-bucket budget for one filtered request, shared by all
486    /// three list APIs. Exhausting it ends the query with `SCAN_LIMIT` and a
487    /// resume cursor, bounding the worst-case scan cost of a sparse filter.
488    ///
489    /// Defaults to `1024` if not specified.
490    #[serde(skip_serializing_if = "Option::is_none")]
491    pub bitmap_bucket_scan_budget: Option<usize>,
492
493    /// Per-chunk evaluated-bucket cap. A chunk that hits this while the request
494    /// budget remains emits a progress watermark and resumes in the next chunk,
495    /// so a long sparse scan reports incremental progress. Clamped to
496    /// `bitmap_bucket_scan_budget`.
497    ///
498    /// Defaults to `256` if not specified.
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub chunk_bucket_scan_budget: Option<usize>,
501
502    /// Maximum total filter literals (bitmap dimensions) accepted in one filtered
503    /// request, across all DNF terms. Each literal becomes one bitmap leaf, so
504    /// this bounds a single filter's scan fanout. Must not exceed
505    /// `bitmap_bucket_scan_budget` (see [`LedgerHistoryConfig::validate`]).
506    ///
507    /// Defaults to `10` if not specified.
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub max_bitmap_filter_literals: Option<usize>,
510}
511
512impl LedgerHistoryConfig {
513    pub fn list_transactions(&self) -> ResolvedLedgerHistoryMethodConfig {
514        LedgerHistoryMethodConfig::resolve(
515            self.list_transactions.as_ref(),
516            LIST_TRANSACTIONS_DEFAULTS,
517        )
518    }
519
520    pub fn list_events(&self) -> ResolvedLedgerHistoryMethodConfig {
521        LedgerHistoryMethodConfig::resolve(self.list_events.as_ref(), LIST_EVENTS_DEFAULTS)
522    }
523
524    pub fn list_checkpoints(&self) -> ResolvedLedgerHistoryMethodConfig {
525        LedgerHistoryMethodConfig::resolve(
526            self.list_checkpoints.as_ref(),
527            LIST_CHECKPOINTS_DEFAULTS,
528        )
529    }
530
531    pub fn bitmap_bucket_scan_budget(&self) -> usize {
532        self.bitmap_bucket_scan_budget
533            .unwrap_or(DEFAULT_BITMAP_BUCKET_SCAN_BUDGET)
534    }
535
536    pub fn chunk_bucket_scan_budget(&self) -> usize {
537        self.chunk_bucket_scan_budget
538            .unwrap_or(DEFAULT_CHUNK_BUCKET_SCAN_BUDGET)
539            .min(self.bitmap_bucket_scan_budget())
540    }
541
542    pub fn max_bitmap_filter_literals(&self) -> usize {
543        self.max_bitmap_filter_literals
544            .unwrap_or(DEFAULT_MAX_BITMAP_FILTER_LITERALS)
545    }
546
547    /// Reject configurations that cannot make forward progress. Each filter
548    /// literal becomes one bitmap leaf that must fetch at least one bucket to
549    /// emit its first watermark; if the per-request budget is below the literal
550    /// cap a `SCAN_LIMIT` can fire before any merged watermark reaches the wire,
551    /// leaving the client a cursorless `QueryEnd` it cannot resume from. Mirrors
552    /// the archival/BigTable side's `LedgerHistoryConfig::validate`.
553    pub fn validate(&self) -> anyhow::Result<()> {
554        anyhow::ensure!(
555            self.bitmap_bucket_scan_budget() >= self.max_bitmap_filter_literals(),
556            "ledger_history.bitmap_bucket_scan_budget ({}) must be >= \
557             max_bitmap_filter_literals ({}) so every filter leaf gets at least one \
558             bucket before SCAN_LIMIT",
559            self.bitmap_bucket_scan_budget(),
560            self.max_bitmap_filter_literals(),
561        );
562        Ok(())
563    }
564}
sui_config/rpc_config.rs

sui_config/
rpc_config.rs
