test: 💍 Add test about opentx simple multisig transfer

Author: Liu Chuankai

src/tests/opentx.rs

@@ -101,8 +101,6 @@ fn test_omnilock_simple_hash(mut cfg: OmniLockConfig) {
     let mut tx = builder
         .build_balanced(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
         .unwrap();
-    tx = OmniLockTransferBuilder::remove_open_out(tx);
-
     let mut rng = rand::thread_rng();
     let salt: u32 = rng.gen();
     let wit = OpentxWitness::new_sig_all_relative(&tx, Some(salt)).unwrap();
@@ -172,12 +170,149 @@ fn test_omnilock_simple_hash(mut cfg: OmniLockConfig) {
     assert_eq!(tx.inputs().len(), 2);
     assert_eq!(tx.outputs().len(), 2);
     assert_eq!(tx.output(0).unwrap(), output);
-    assert_eq!(tx.output(1).unwrap().lock(), receiver);
+    let output1 = tx.output(1).unwrap();
+    assert_eq!(output1.lock(), receiver);
+    let receiver_capacity: u64 = output1.capacity().unpack();
+    assert!(receiver_capacity - 100 * ONE_CKB < ONE_CKB );
+    let witnesses = tx
+        .witnesses()
+        .into_iter()
+        .map(|w| w.raw_data())
+        .collect::<Vec<_>>();
+    assert_eq!(witnesses.len(), 2);
+    ctx.verify(tx, FEE_RATE).unwrap();
+}
+
+/// multisig(200) => multisig(exchange 199) + open pay 1, locked by account0, account1, account2
+/// account3(400) => account2(401 - transaction fee)
+#[test]
+fn test_omnilock_transfer_from_multisig() {
+    let unlock_mode = OmniUnlockMode::Normal;
+    let lock_args = vec![
+        ACCOUNT0_ARG.clone(),
+        ACCOUNT1_ARG.clone(),
+        ACCOUNT2_ARG.clone(),
+    ];
+    let multi_cfg = MultisigConfig::new_with(lock_args, 0, 2).unwrap();
+    let mut cfg = OmniLockConfig::new_multisig(multi_cfg);
+    cfg.set_opentx_mode();
+
+    let sender = build_omnilock_script(&cfg);
+    let receiver = build_sighash_script(ACCOUNT3_ARG);
+
+    let ctx = init_context(
+        vec![(OMNILOCK_BIN, true)],
+        vec![
+            (sender.clone(), Some(200 * ONE_CKB)),
+            (sender.clone(), Some(300 * ONE_CKB)),
+            (receiver.clone(), Some(400 * ONE_CKB)),
+            (receiver.clone(), Some(500 * ONE_CKB)),
+            (receiver.clone(), Some(600 * ONE_CKB)),
+        ],
+    );
+
+    let output = CellOutput::new_builder()
+        .capacity((199 * ONE_CKB).pack())
+        .lock(receiver.clone())
+        .build();
+    let builder = OmniLockTransferBuilder::new_open(
+        (1 * ONE_CKB).into(),
+        vec![(output.clone(), Bytes::default())],
+        cfg.clone(),
+        None,
+    );
+    let placeholder_witness = cfg.placeholder_witness(unlock_mode).unwrap();
+    let balancer =
+        CapacityBalancer::new_simple(sender.clone(), placeholder_witness.clone(), ZERO_FEE_RATE);
+
+    let mut cell_collector = ctx.to_live_cells_context();
+    let account0_key = secp256k1::SecretKey::from_slice(ACCOUNT0_KEY.as_bytes()).unwrap();
+    let account2_key = secp256k1::SecretKey::from_slice(ACCOUNT2_KEY.as_bytes()).unwrap();
+    let unlockers = build_omnilock_unlockers(account0_key, cfg.clone(), unlock_mode);
+    let mut tx = builder
+        .build_balanced(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
+        .unwrap();
+    // add opentx hash data
+    let mut rng = rand::thread_rng();
+    let salt: u32 = rng.gen();
+    let wit = OpentxWitness::new_sig_all_relative(&tx, Some(salt)).unwrap();
+    cfg.set_opentx_input(wit);
+    tx = OmniLockTransferBuilder::update_opentx_witness(
+        tx,
+        &cfg,
+        OmniUnlockMode::Normal,
+        &ctx,
+        &sender,
+    )
+    .unwrap();
+    for key in [account0_key, account2_key] {
+        let unlockers = build_omnilock_unlockers(key, cfg.clone(), unlock_mode);
+        let (new_tx, new_locked_groups) = unlock_tx(tx.clone(), &ctx, &unlockers).unwrap();
+        assert!(new_locked_groups.is_empty());
+        tx = new_tx;
+    }
+
+    println!(
+        "> tx: {}",
+        serde_json::to_string_pretty(&json_types::TransactionView::from(tx.clone())).unwrap()
+    );
+    // use the opentx
+
+    // Build ScriptUnlocker
+    let account3_key = secp256k1::SecretKey::from_slice(ACCOUNT3_KEY.as_bytes()).unwrap();
+    let signer = SecpCkbRawKeySigner::new_with_secret_keys(vec![account3_key]);
+    let sighash_unlocker = SecpSighashUnlocker::from(Box::new(signer) as Box<_>);
+    let sighash_script_id = ScriptId::new_type(SIGHASH_TYPE_HASH.clone());
+    let mut unlockers = HashMap::default();
+    unlockers.insert(
+        sighash_script_id,
+        Box::new(sighash_unlocker) as Box<dyn ScriptUnlocker>,
+    );
+
+    // Build CapacityBalancer
+    let placeholder_witness = WitnessArgs::new_builder()
+        .lock(Some(Bytes::from(vec![0u8; 65])).pack())
+        .build();
+    let balancer =
+        CapacityBalancer::new_simple(receiver.clone(), placeholder_witness.clone(), 1000);
+    // // Build the transaction
+    let query = CellQueryOptions::new_lock(receiver.clone());
+    let (inputs, total_capacity) = cell_collector.collect_live_cells(&query, false).unwrap();
+    let input = &inputs[0];
+    let input_output = &input.out_point;
+    println!("{:#x} total_capacity: {}", input_output, total_capacity);
+    // let output = CellOutput::new_builder()
+    //     .lock(receiver.clone())
+    //     .capacity((100 * ONE_CKB).pack())
+    //     .build();
+    let builder = CapacityTransferBuilderWithTransaction::new(
+        vec![/*(output.clone(), Bytes::default())*/],
+        tx,
+    );
+    let (tx, still_locked_groups) = builder
+        .build_unlocked(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
+        .unwrap();
+
+    println!(
+        "> tx: {}",
+        serde_json::to_string_pretty(&json_types::TransactionView::from(tx.clone())).unwrap()
+    );
+    assert_eq!(1, still_locked_groups.len());
+    assert_eq!(tx.header_deps().len(), 0);
+    assert_eq!(tx.cell_deps().len(), 2);
+    assert_eq!(tx.inputs().len(), 2);
+    assert_eq!(tx.outputs().len(), 2);
+    assert_eq!(tx.output(0).unwrap(), output);
+    let output1 = tx.output(1).unwrap();
+    assert_eq!(output1.lock(), receiver);
+    let receiver_capacity: u64 = output1.capacity().unpack();
+    assert!(receiver_capacity - 400 * ONE_CKB < ONE_CKB );
     let witnesses = tx
         .witnesses()
         .into_iter()
         .map(|w| w.raw_data())
         .collect::<Vec<_>>();
     assert_eq!(witnesses.len(), 2);
+    assert_eq!(witnesses[1].len(), placeholder_witness.as_slice().len());
     ctx.verify(tx, FEE_RATE).unwrap();
 }

src/tx_builder/omni_lock.rs

@@ -1,4 +1,4 @@
-use std::collections::HashSet;
+use std::collections::{HashSet, HashMap};
 
 use ckb_types::{
     bytes::Bytes,
@@ -8,10 +8,10 @@ use ckb_types::{
     H256,
 };
 
-use super::{TxBuilder, TxBuilderError};
+use super::{TxBuilder, TxBuilderError, CapacityBalancer, fill_placeholder_witnesses, balance_tx_capacity};
 use crate::{
     traits::{CellCollector, CellDepResolver, HeaderDepResolver, TransactionDependencyProvider},
-    unlock::{omni_lock::ConfigError, OmniLockConfig, OmniUnlockMode},
+    unlock::{omni_lock::ConfigError, OmniLockConfig, OmniUnlockMode, ScriptUnlocker},
 };
 use crate::{types::ScriptId, HumanCapacity};
 
@@ -206,4 +206,39 @@ impl TxBuilder for OmniLockTransferBuilder {
             .set_outputs_data(outputs_data)
             .build())
     }
+
+    /// Build balanced transaction that ready to sign:
+    ///  * Build base transaction
+    ///  * Fill placeholder witness for lock script
+    ///  * balance the capacity
+    fn build_balanced(
+        &self,
+        cell_collector: &mut dyn CellCollector,
+        cell_dep_resolver: &dyn CellDepResolver,
+        header_dep_resolver: &dyn HeaderDepResolver,
+        tx_dep_provider: &dyn TransactionDependencyProvider,
+        balancer: &CapacityBalancer,
+        unlockers: &HashMap<ScriptId, Box<dyn ScriptUnlocker>>,
+    ) -> Result<TransactionView, TxBuilderError> {
+        let base_tx = self.build_base(
+            cell_collector,
+            cell_dep_resolver,
+            header_dep_resolver,
+            tx_dep_provider,
+        )?;
+        let (tx_filled_witnesses, _) =
+            fill_placeholder_witnesses(base_tx, tx_dep_provider, unlockers)?;
+        let mut tx = balance_tx_capacity(
+            &tx_filled_witnesses,
+            balancer,
+            cell_collector,
+            tx_dep_provider,
+            cell_dep_resolver,
+            header_dep_resolver,
+        )?;
+        if self.cfg.is_opentx_mode() {
+            tx = OmniLockTransferBuilder::remove_open_out(tx);
+        }
+        Ok(tx)
+    }
 }

src/unlock/omni_lock.rs

@@ -558,6 +558,11 @@ impl OmniLockConfig {
         self.omni_lock_flags.set(OmniLockFlags::OPENTX, true);
     }
 
+    /// Check if it contains open transaction mode
+    pub fn is_opentx_mode(&self) -> bool {
+        self.omni_lock_flags.contains(OmniLockFlags::OPENTX)
+    }
+
     /// Clear the open transaction input data, and clear OmniLockFlags::OPENTX from omni_lock_flags.
     pub fn clear_opentx_input(&mut self) {
         self.omni_lock_flags.set(OmniLockFlags::OPENTX, false);