Fix Error about CI (e2e)

Author: joii2020

crates/fiber-lib/src/ckb/funding/funding_tx.rs

@@ -122,7 +122,9 @@ struct ExtraCellDepResolver<'a> {
 impl CellDepResolver for ExtraCellDepResolver<'_> {
     fn resolve(&self, script: &Script) -> Option<packed::CellDep> {
         if script == self.funding_source_lock_script {
-            return self.funding_source_extra_cell_deps.first().cloned();
+            if let Some(cell_dep) = self.funding_source_extra_cell_deps.first() {
+                return Some(cell_dep.clone());
+            }
         }
         self.default.resolve(script)
     }
@@ -604,16 +606,14 @@ impl ExternalFundingTxBuilder {
     fn build_funding_cell(&self) -> Result<(packed::CellOutput, packed::Bytes), FundingError> {
         match self.request.udt_type_script {
             Some(ref udt_type_script) => {
-                let udt_amount = self
-                    .request
-                    .local_amount
-                    .checked_add(self.request.remote_amount)
-                    .ok_or(FundingError::OverflowError)?;
-                let ckb_amount = self
-                    .request
-                    .local_reserved_ckb_amount
-                    .checked_add(self.request.remote_reserved_ckb_amount)
-                    .ok_or(FundingError::OverflowError)?;
+                if self.request.remote_amount > 0 || self.request.remote_reserved_ckb_amount > 0 {
+                    debug!(
+                        "Ignoring remote initial funding in external funding tx builder: remote_amount={}, remote_reserved_ckb_amount={}",
+                        self.request.remote_amount, self.request.remote_reserved_ckb_amount
+                    );
+                }
+                let udt_amount = self.request.local_amount;
+                let ckb_amount = self.request.local_reserved_ckb_amount;
 
                 let udt_output = packed::CellOutput::new_builder()
                     .capacity(Capacity::shannons(ckb_amount).pack())
@@ -627,14 +627,24 @@ impl ExternalFundingTxBuilder {
                 Ok((udt_output, data.freeze().pack()))
             }
             None => {
+                if self.request.remote_amount > 0 || self.request.remote_reserved_ckb_amount > 0 {
+                    debug!(
+                        "Ignoring remote initial funding in external funding tx builder: remote_amount={}, remote_reserved_ckb_amount={}",
+                        self.request.remote_amount, self.request.remote_reserved_ckb_amount
+                    );
+                }
                 let local_amount = u64::try_from(self.request.local_amount)
                     .map_err(|_| FundingError::OverflowError)?;
                 let remote_amount = u64::try_from(self.request.remote_amount)
                     .map_err(|_| FundingError::OverflowError)?;
+                if remote_amount > 0 {
+                    debug!(
+                        "Ignoring remote CKB amount in external funding tx builder after cast: {}",
+                        remote_amount
+                    );
+                }
                 let ckb_amount = local_amount
                     .checked_add(self.request.local_reserved_ckb_amount)
-                    .and_then(|amount| amount.checked_add(remote_amount))
-                    .and_then(|amount| amount.checked_add(self.request.remote_reserved_ckb_amount))
                     .ok_or(FundingError::OverflowError)?;
                 let ckb_output = packed::CellOutput::new_builder()
                     .capacity(Capacity::shannons(ckb_amount).pack())
@@ -949,6 +959,19 @@ impl FundingTx {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct StubCellDepResolver {
+        resolved: packed::CellDep,
+        call_count: AtomicUsize,
+    }
+
+    impl CellDepResolver for StubCellDepResolver {
+        fn resolve(&self, _script: &Script) -> Option<packed::CellDep> {
+            self.call_count.fetch_add(1, Ordering::Relaxed);
+            Some(self.resolved.clone())
+        }
+    }
 
     /// Build a dummy ExternalFundingContext for unit tests.
     fn dummy_external_context() -> ExternalFundingContext {
@@ -961,6 +984,28 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_extra_cell_dep_resolver_falls_back_when_no_extra_dep() {
+        let fallback_cell_dep = packed::CellDep::default();
+        let default_resolver = StubCellDepResolver {
+            resolved: fallback_cell_dep.clone(),
+            call_count: AtomicUsize::new(0),
+        };
+        let funding_source_lock_script = Script::default();
+        let resolver = ExtraCellDepResolver {
+            default: &default_resolver,
+            funding_source_lock_script: &funding_source_lock_script,
+            funding_source_extra_cell_deps: &[],
+        };
+
+        let resolved = resolver
+            .resolve(&funding_source_lock_script)
+            .expect("fallback cell dep should resolve");
+
+        assert_eq!(resolved, fallback_cell_dep);
+        assert_eq!(default_resolver.call_count.load(Ordering::Relaxed), 1);
+    }
+
     #[test]
     fn test_external_funding_build_ckb_funding_cell() {
         let context = dummy_external_context();
@@ -982,11 +1027,9 @@ mod tests {
 
         let (output, data) = builder.build_funding_cell().expect("build funding cell");
 
-        // For CKB channels: capacity = local_amount + remote_amount + local_reserved + remote_reserved
-        let expected_capacity: u64 = request.local_amount as u64
-            + request.remote_amount as u64
-            + request.local_reserved_ckb_amount
-            + request.remote_reserved_ckb_amount;
+        // For external CKB channels: capacity = local_amount + local_reserved.
+        let expected_capacity: u64 =
+            request.local_amount as u64 + request.local_reserved_ckb_amount;
         let actual_capacity: u64 = output.capacity().unpack();
         assert_eq!(actual_capacity, expected_capacity);
 
@@ -1026,9 +1069,8 @@ mod tests {
 
         let (output, data) = builder.build_funding_cell().expect("build funding cell");
 
-        // For UDT channels: capacity = local_reserved + remote_reserved
-        let expected_capacity =
-            request.local_reserved_ckb_amount + request.remote_reserved_ckb_amount;
+        // For external UDT channels: capacity = local_reserved only.
+        let expected_capacity = request.local_reserved_ckb_amount;
         let actual_capacity: u64 = output.capacity().unpack();
         assert_eq!(actual_capacity, expected_capacity);
 
@@ -1041,8 +1083,8 @@ mod tests {
             udt_type_script
         );
 
-        // Data should contain the total UDT amount (16 bytes, little-endian)
-        let expected_udt_amount: u128 = request.local_amount + request.remote_amount;
+        // Data should contain only the local UDT amount (16 bytes, little-endian).
+        let expected_udt_amount: u128 = request.local_amount;
         let data_bytes = data.raw_data();
         assert_eq!(data_bytes.len(), 16);
         let mut amount_bytes = [0u8; 16];
@@ -1067,7 +1109,7 @@ mod tests {
 
         let builder = ExternalFundingTxBuilder {
             funding_tx: FundingTx::new(),
-            request,
+            request: request.clone(),
             context,
         };
 
@@ -1080,14 +1122,13 @@ mod tests {
     }
 
     #[test]
-    fn test_external_funding_build_udt_funding_cell_overflow() {
+    fn test_external_funding_build_udt_funding_cell_ignores_remote_amount() {
         let context = dummy_external_context();
         let udt_type_script = Script::new_builder()
             .code_hash(packed::Byte32::from_slice(&[1u8; 32]).unwrap())
             .hash_type(packed::Byte::new(0))
             .build();
 
-        // UDT amounts that overflow u128
         let request = FundingRequest {
             script: Script::default(),
             udt_type_script: Some(udt_type_script),
@@ -1100,16 +1141,20 @@ mod tests {
 
         let builder = ExternalFundingTxBuilder {
             funding_tx: FundingTx::new(),
-            request,
+            request: request.clone(),
             context,
         };
 
-        let result = builder.build_funding_cell();
-        assert!(result.is_err(), "should overflow");
-        match result {
-            Err(FundingError::OverflowError) => {} // expected
-            other => panic!("expected OverflowError, got {:?}", other),
-        }
+        let (output, data) = builder.build_funding_cell().expect("build funding cell");
+
+        let actual_capacity: u64 = output.capacity().unpack();
+        assert_eq!(actual_capacity, request.local_reserved_ckb_amount);
+
+        let data_bytes = data.raw_data();
+        assert_eq!(data_bytes.len(), 16);
+        let mut amount_bytes = [0u8; 16];
+        amount_bytes.copy_from_slice(&data_bytes[..16]);
+        assert_eq!(u128::from_le_bytes(amount_bytes), request.local_amount);
     }
 
     #[test]

crates/fiber-lib/src/fiber/channel.rs

@@ -5470,6 +5470,16 @@ impl ChannelActorState {
             }
         }
 
+        if self.ephemeral_config.external_funding.enabled {
+            if self.to_remote_amount > 0 || self.remote_reserved_ckb_amount > 0 {
+                return Err(ProcessingChannelError::InvalidParameter(format!(
+                    "External funding requires zero remote initial funding, got remote_amount={} remote_reserved_ckb_amount={}",
+                    self.to_remote_amount, self.remote_reserved_ckb_amount
+                )));
+            }
+            return Ok(());
+        }
+
         // reserved_ckb_amount
         let occupied_capacity =
             occupied_capacity(&self.get_remote_shutdown_script(), udt_type_script)?.as_u64();
@@ -6825,6 +6835,18 @@ impl ChannelActorState {
 
         self.to_remote_amount = accept_channel.funding_amount;
         self.remote_reserved_ckb_amount = accept_channel.reserved_ckb_amount;
+        if self.ephemeral_config.external_funding.enabled {
+            if accept_channel.funding_amount > 0 || accept_channel.reserved_ckb_amount > 0 {
+                warn!(
+                    "Normalizing acceptor initial funding to zero for external funding channel {:?}: remote_amount={}, remote_reserved_ckb_amount={}",
+                    self.get_id(),
+                    accept_channel.funding_amount,
+                    accept_channel.reserved_ckb_amount
+                );
+            }
+            self.to_remote_amount = 0;
+            self.remote_reserved_ckb_amount = 0;
+        }
 
         self.commit_remote_nonce(accept_channel.next_commitment_nonce.clone());
         self.remote_revocation_nonce_for_send = Some(accept_channel.next_revocation_nonce.clone());
@@ -6927,6 +6949,7 @@ impl ChannelActorState {
         };
         match msg {
             TxCollaborationMsg::TxUpdate(msg) => {
+                self.maybe_adapt_acceptor_to_remote_only_funding(&msg.tx)?;
                 if self.ephemeral_config.external_funding.enabled
                     && self.ephemeral_config.external_funding.signed_submitted
                 {
@@ -7021,6 +7044,68 @@ impl ChannelActorState {
         Ok(())
     }
 
+    fn maybe_adapt_acceptor_to_remote_only_funding(
+        &mut self,
+        tx: &Transaction,
+    ) -> Result<(), ProcessingChannelError> {
+        let placeholder_witness = packed::WitnessArgs::new_builder()
+            .lock(Some(molecule::bytes::Bytes::from(vec![0u8; 170])).pack())
+            .build()
+            .as_bytes()
+            .to_vec();
+        let has_non_placeholder_witness = tx.witnesses().into_iter().any(|witness| {
+            let witness: Vec<u8> = witness.unpack();
+            witness != placeholder_witness
+        });
+        if !self.is_acceptor
+            || !has_non_placeholder_witness
+            || self.funding_tx.is_some()
+            || (self.to_local_amount == 0 && self.local_reserved_ckb_amount == 0)
+        {
+            return Ok(());
+        }
+
+        let tx = tx.clone().into_view();
+        let first_output = match tx.outputs().get(0) {
+            Some(output) => output,
+            None => return Ok(()),
+        };
+
+        if first_output.lock() != self.get_funding_lock_script() {
+            return Ok(());
+        }
+
+        let current_capacity: u64 = first_output.capacity().unpack();
+        let is_remote_only_funding = if self.funding_udt_type_script.is_some() {
+            let Some((_output, data)) = tx.output_with_data(0) else {
+                return Ok(());
+            };
+            if data.as_ref().len() < 16 {
+                return Ok(());
+            }
+            let mut amount_bytes = [0u8; 16];
+            amount_bytes.copy_from_slice(&data.as_ref()[0..16]);
+            let udt_amount = u128::from_le_bytes(amount_bytes);
+            current_capacity == self.remote_reserved_ckb_amount
+                && udt_amount == self.to_remote_amount
+        } else {
+            current_capacity == self.to_remote_amount as u64 + self.remote_reserved_ckb_amount
+        };
+
+        if is_remote_only_funding {
+            warn!(
+                "Adapting acceptor channel {:?} to remote-only funding after receiving a fully signed external funding tx: local_amount={}, local_reserved_ckb_amount={}",
+                self.get_id(),
+                self.to_local_amount,
+                self.local_reserved_ckb_amount
+            );
+            self.to_local_amount = 0;
+            self.local_reserved_ckb_amount = 0;
+        }
+
+        Ok(())
+    }
+
     fn verify_commitment_signed_and_send_ack(
         &mut self,
         commitment_signed: CommitmentSigned,

crates/fiber-lib/src/fiber/network.rs

@@ -1168,15 +1168,22 @@ where
                     });
 
                 if let Some(reply) = reply {
+                    if remote_funding_amount > 0 || remote_reserved_ckb_amount > 0 {
+                        debug!(
+                            "Ignoring remote initial funding for external funding channel {:?}: remote_amount={}, remote_reserved_ckb_amount={}",
+                            new_channel_id, remote_funding_amount, remote_reserved_ckb_amount
+                        );
+                    }
+
                     // Build the unsigned funding transaction
                     let request = FundingRequest {
                         script: funding_source_lock_script.clone(),
                         udt_type_script: funding_udt_type_script,
                         local_amount: funding_amount,
-                        remote_amount: remote_funding_amount,
+                        remote_amount: 0,
                         funding_fee_rate,
                         local_reserved_ckb_amount,
-                        remote_reserved_ckb_amount,
+                        remote_reserved_ckb_amount: 0,
                     };
 
                     let funding_tx = FundingTx::new();

tests/bruno/e2e/external-funding-open/README.md

@@ -9,6 +9,10 @@ export REMOVE_OLD_STATE=y
 
 This test validates a success-only scenario:
 
+- `open_channel_with_external_funding` is single-sided initial funding:
+  - the external signer pays only the initiator's channel balance, reserve, and tx fee;
+  - the peer starts with no initial funded reserve.
+
 - Get node1/node2/node3 CKB balances before open.
 - Node1 opens an external-funded channel to node3 via:
   - `open_channel_with_external_funding`