feat: support external wallet signing for channel funding

crates/fiber-lib/Cargo.toml

@@ -147,6 +147,7 @@ jsonrpsee = { version = "0.25.1", features = [
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wasm-bindgen-test = "0.3.50"
+wasm-bindgen-futures = "0.4.50"
 
 [lints.clippy]
 expect-fun-call = "allow"

crates/fiber-lib/src/ckb/actor.rs

@@ -18,7 +18,7 @@ use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
 use super::{
-    funding::{FundingContext, LiveCellsExclusionMap},
+    funding::{ExternalFundingContext, FundingContext, LiveCellsExclusionMap},
     signer::LocalSigner,
     tx_tracing_actor::{
         CkbTxTracer, CkbTxTracingActor, CkbTxTracingArguments, CkbTxTracingMessage,
@@ -46,6 +46,16 @@ pub enum CkbChainMessage {
         FundingRequest,
         RpcReplyPort<Result<FundingTx, FundingError>>,
     ),
+    /// Build an unsigned funding transaction for external signing.
+    /// The user will sign this transaction with their own wallet.
+    BuildUnsignedFundingTx {
+        funding_tx: FundingTx,
+        request: FundingRequest,
+        funding_source_lock_script: packed::Script,
+        funding_source_lock_script_cell_deps: Vec<packed::CellDep>,
+        funding_cell_lock_script: packed::Script,
+        reply: RpcReplyPort<Result<FundingTx, FundingError>>,
+    },
     VerifyFundingTx {
         local_tx: packed::Transaction,
         remote_tx: packed::Transaction,
@@ -132,6 +142,29 @@ impl Actor for CkbChainActor {
                 };
                 let _ = reply_port.send(result);
             }
+            CkbChainMessage::BuildUnsignedFundingTx {
+                funding_tx,
+                request,
+                funding_source_lock_script,
+                funding_source_lock_script_cell_deps,
+                funding_cell_lock_script,
+                reply,
+            } => {
+                let context = ExternalFundingContext {
+                    rpc_url: state.config.rpc_url.clone(),
+                    funding_source_lock_script,
+                    funding_source_lock_script_cell_deps,
+                    funding_cell_lock_script,
+                };
+                let result = funding_tx
+                    .build_unsigned_for_external_funding(
+                        request,
+                        context,
+                        &mut state.live_cells_exclusion_map,
+                    )
+                    .await;
+                let _ = reply.send(result);
+            }
             CkbChainMessage::VerifyFundingTx {
                 local_tx,
                 remote_tx,

crates/fiber-lib/src/ckb/config.rs

@@ -199,7 +199,8 @@ serde_with::serde_conv!(
 );
 
 serde_with::serde_conv!(
-    DepTypeWrapper,
+    /// Wrapper for DepType serialization that supports both `dep_group` and `depGroup` formats.
+    pub DepTypeWrapper,
     DepType,
     |s: &DepType| -> String {
         let v = match s {
@@ -209,15 +210,46 @@ serde_with::serde_conv!(
         v.to_string()
     },
     |s: String| {
+        // Support both snake_case (dep_group) and camelCase (depGroup) from JS libraries
         let v = match s.to_lowercase().as_str() {
             "code" => DepType::Code,
-            "dep_group" => DepType::DepGroup,
-            _ => return Err("invalid hash type"),
+            "dep_group" | "depgroup" => DepType::DepGroup,
+            _ => return Err("invalid dep type"),
         };
         Ok(v)
     }
 );
 
+/// Wrapper for ckb_jsonrpc_types::DepType that supports both `dep_group` and `depGroup` formats.
+/// This is used for RPC serialization compatibility with JS libraries like Lumos.
+pub mod json_dep_type {
+    use ckb_jsonrpc_types::DepType;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    pub fn serialize<S>(dep_type: &DepType, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let s = match dep_type {
+            DepType::Code => "code",
+            DepType::DepGroup => "dep_group",
+        };
+        s.serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<DepType, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        match s.to_lowercase().as_str() {
+            "code" => Ok(DepType::Code),
+            "dep_group" | "depgroup" => Ok(DepType::DepGroup),
+            _ => Err(serde::de::Error::custom("invalid dep type")),
+        }
+    }
+}
+
 #[serde_as]
 #[derive(Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq, Hash)]
 pub struct UdtScript {