light-client-wasm: support using JS object as configuration

wasm/light-client-js/src/index.ts

@@ -52,8 +52,14 @@ class LightClient {
      * @param networkSecretKey A secret key used to derive keys during data transport between nodes. This key should be persistent for a unique client.
      * @param logLevel Log Level for light-client-db-worker and light-client-wasm
      * @param transportType Specify transport type. `ws` stands for non-secure WebSocket, while `wss` stands for WebSocket over SSL.
+     * @param networkConfigIsJSObject Sets to true if `NetworkSetting.config` is provided as a JS object, otherwise it should be a TOML string.
      */
-    async start(networkSetting: NetworkSetting, networkSecretKey: Hex, logLevel: "trace" | "debug" | "info" | "error" = "info", transportType: "ws" | "wss" = "ws") {
+    async start(
+        networkSetting: NetworkSetting,
+        networkSecretKey: Hex,
+        logLevel: "trace" | "debug" | "info" | "error" = "info", transportType: "ws" | "wss" = "ws",
+        networkConfigIsJSObject: boolean = false,
+    ) {
         this.dbWorker.postMessage({
             inputBuffer: this.inputBuffer,
             outputBuffer: this.outputBuffer,
@@ -66,7 +72,8 @@ class LightClient {
             logLevel: logLevel,
             traceLogBuffer: this.traceLogBuffer,
             networkSecretKey: bytesFrom(networkSecretKey),
-            transportType
+            transportType,
+            networkConfigIsJSObject
         } as LightClientWorkerInitializeOptions);
         await new Promise<void>((res, rej) => {
             this.dbWorker.onmessage = () => res();

wasm/light-client-js/src/lightclient.worker.ts

@@ -8,7 +8,16 @@ onmessage = async (evt) => {
     if (!loaded) {
         const data = evt.data as LightClientWorkerInitializeOptions;
         wasmModule.set_shared_array(data.inputBuffer, data.outputBuffer);
-        await wasmModule.light_client(data.networkFlag, data.logLevel, data.networkSecretKey, data.transportType);
+        if (data.networkConfigIsJSObject) {
+            data.networkFlag.config = JSON.stringify(data.networkFlag.config);
+        }
+        await wasmModule.light_client(
+            data.networkFlag,
+            data.logLevel,
+            data.networkSecretKey,
+            data.transportType,
+            data.networkConfigIsJSObject,
+        );
         self.postMessage({});
         loaded = true;
         return;

wasm/light-client-js/src/types.ts

@@ -21,7 +21,8 @@ interface DbWorkerInitializeOptions extends WorkerInitializeOptions {
 
 interface LightClientWorkerInitializeOptions extends WorkerInitializeOptions {
     networkFlag: NetworkSetting;
-    networkSecretKey: Uint8Array
+    networkSecretKey: Uint8Array;
+    networkConfigIsJSObject: boolean;
 };
 
 interface LightClientFunctionCall {
@@ -178,7 +179,9 @@ export function localNodeTo(input: LightClientLocalNode): LocalNode {
         version: input.version
     })
 }
-type NetworkSetting = { type: "MainNet"; config?: string; } | { type: "TestNet"; config?: string; } | { type: "DevNet"; spec: string; config: string; };
+type NetworkSetting = { type: "MainNet"; config?: string | any; } |
+{ type: "TestNet"; config?: string | any; } |
+{ type: "DevNet"; spec: string; config: string | any; };
 export enum LightClientSetScriptsCommand {
     All = 0,
     Partial = 1,

wasm/light-client-wasm/Cargo.toml

@@ -35,6 +35,7 @@ ckb-app-config = "0.202.0"
 
 getrandom = { version = "0.2", features = ["js"] }
 tokio = { version = "1.20" }
+toml = "0.8.23"
 
 [features]
 default = ["console_error_panic_hook"]

wasm/light-client-wasm/src/lib.rs

@@ -93,6 +93,7 @@ pub async fn light_client(
     log_level: String,
     network_secret_key: JsValue,
     wasm_transport_type: JsValue,
+    network_config_is_json: bool,
 ) -> Result<(), JsValue> {
     if !status(0b0) {
         return Err(JsValue::from_str("Can't start twice"));
@@ -109,20 +110,35 @@ pub async fn light_client(
         "Starting with wasm transport type = {:?}",
         wasm_transport_type
     );
-    let mut config = match &network_flag {
+    enum NetworkConfigType<'a> {
+        Default(&'a str),
+        UserDefined(&'a str),
+    }
+    let config_string = match &network_flag {
         NetworkSetting::TestNet { config } => config
             .as_ref()
-            .map_or(TESTNET_CONFIG, |v| v)
-            .parse::<RunEnv>()
-            .unwrap(),
+            .map_or(NetworkConfigType::Default(TESTNET_CONFIG), |v| {
+                NetworkConfigType::UserDefined(v.as_str())
+            }),
         NetworkSetting::MainNet { config } => config
             .as_ref()
-            .map_or(MAINNET_CONFIG, |v| v)
-            .parse::<RunEnv>()
-            .unwrap(),
-        NetworkSetting::DevNet { config, .. } => config.parse::<RunEnv>().unwrap(),
+            .map_or(NetworkConfigType::Default(MAINNET_CONFIG), |v| {
+                NetworkConfigType::UserDefined(v.as_str())
+            }),
+        NetworkSetting::DevNet { config, .. } => NetworkConfigType::UserDefined(config.as_str()),
+    };
+    let mut config = match config_string {
+        NetworkConfigType::Default(s) => s.parse::<RunEnv>().unwrap(),
+        NetworkConfigType::UserDefined(s) => {
+            if network_config_is_json {
+                serde_json::from_str(s)
+                    .map_err(|e| format!("Unable to parse network setting from json: {}", e))?
+            } else {
+                s.parse::<RunEnv>()
+                    .map_err(|e| format!("Unable to parse network setting from toml: {}", e))?
+            }
+        }
     };
-
     let storage = Storage::new(&config.store.path);
     let chain_spec = ChainSpec::load_from(&match network_flag {
         NetworkSetting::MainNet { .. } => Resource::bundled("specs/mainnet.toml".to_string()),