test: 💍 Tests with index opentx input to end a transaction

Author: Liu Chuankai

src/tests/omni_lock.rs

@@ -118,7 +118,7 @@ fn test_omnilock_simple_hash(cfg: OmniLockConfig) {
 
     let mut cell_collector = ctx.to_live_cells_context();
     let account0_key = secp256k1::SecretKey::from_slice(ACCOUNT0_KEY.as_bytes()).unwrap();
-    let unlockers = build_omnilock_unlockers(account0_key, cfg.clone(), unlock_mode);
+    let unlockers = build_omnilock_unlockers(account0_key, cfg, unlock_mode);
     let mut tx = builder
         .build_balanced(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
         .unwrap();

src/tests/opentx.rs

@@ -3,43 +3,29 @@ use std::collections::HashMap;
 
 use crate::{
     constants::{ONE_CKB, SIGHASH_TYPE_HASH},
-    test_util::random_out_point,
     tests::{
         build_sighash_script, init_context,
         omni_lock::{build_omnilock_script, build_omnilock_unlockers, OMNILOCK_BIN},
-        omni_lock_util::generate_rc,
-        ACCOUNT0_ARG, ACCOUNT0_KEY, ACCOUNT1_ARG, ACCOUNT1_KEY, ACCOUNT2_ARG, ACCOUNT2_KEY,
-        ACCOUNT3_ARG, ACCOUNT3_KEY, ALWAYS_SUCCESS_BIN, FEE_RATE, SUDT_BIN,
+        ACCOUNT0_ARG, ACCOUNT0_KEY, ACCOUNT1_ARG, ACCOUNT2_ARG, ACCOUNT2_KEY, ACCOUNT3_ARG,
+        ACCOUNT3_KEY, FEE_RATE,
     },
-    traits::{CellCollector, CellDepResolver, CellQueryOptions, SecpCkbRawKeySigner},
+    traits::{CellCollector, CellQueryOptions, SecpCkbRawKeySigner},
     tx_builder::{
-        acp::{AcpTransferBuilder, AcpTransferReceiver},
-        balance_tx_capacity, fill_placeholder_witnesses,
-        omni_lock::OmniLockTransferBuilder,
-        transfer::{CapacityTransferBuilder, CapacityTransferBuilderWithTransaction},
-        udt::{UdtTargetReceiver, UdtTransferBuilder},
-        CapacityProvider, TransferAction,
+        omni_lock::OmniLockTransferBuilder, transfer::CapacityTransferBuilderWithTransaction,
     },
-    types::xudt_rce_mol::SmtProofEntryVec,
     unlock::{
-        omni_lock::{AdminConfig, Identity},
-        opentx::OpentxWitness,
-        IdentityFlag, InfoCellData, MultisigConfig, OmniLockAcpConfig, OmniLockConfig,
-        OmniLockScriptSigner, OmniLockUnlocker, OmniUnlockMode, ScriptUnlocker,
+        opentx::OpentxWitness, MultisigConfig, OmniLockConfig, OmniUnlockMode, ScriptUnlocker,
         SecpSighashUnlocker,
     },
     util::{blake160, keccak160},
-    ScriptId, Since,
+    ScriptId,
 };
 
 use ckb_crypto::secp::{Pubkey, SECP256K1};
-use ckb_hash::blake2b_256;
 use ckb_types::{
     bytes::Bytes,
-    core::{FeeRate, ScriptHashType},
-    packed::{Byte32, CellInput, CellOutput, Script, WitnessArgs},
+    packed::{CellOutput, WitnessArgs},
     prelude::*,
-    H160, H256,
 };
 use rand::Rng;
 
@@ -83,17 +69,16 @@ fn test_omnilock_simple_hash(mut cfg: OmniLockConfig) {
 
     let output = CellOutput::new_builder()
         .capacity((199 * ONE_CKB).pack())
-        .lock(receiver.clone())
+        .lock(sender.clone())
         .build();
     let builder = OmniLockTransferBuilder::new_open(
-        (1 * ONE_CKB).into(),
+        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 balancer = CapacityBalancer::new_simple(sender.clone(), placeholder_witness, ZERO_FEE_RATE);
 
     let mut cell_collector = ctx.to_live_cells_context();
     let account0_key = secp256k1::SecretKey::from_slice(ACCOUNT0_KEY.as_bytes()).unwrap();
@@ -139,8 +124,7 @@ fn test_omnilock_simple_hash(mut cfg: OmniLockConfig) {
     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);
+    let balancer = CapacityBalancer::new_simple(receiver.clone(), placeholder_witness, 1000);
     // // Build the transaction
     let query = CellQueryOptions::new_lock(receiver.clone());
     let (inputs, total_capacity) = cell_collector.collect_live_cells(&query, false).unwrap();
@@ -173,13 +157,8 @@ fn test_omnilock_simple_hash(mut cfg: OmniLockConfig) {
     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);
+    assert!(receiver_capacity - 100 * ONE_CKB < ONE_CKB);
+    assert_eq!(tx.witnesses().len(), 2);
     ctx.verify(tx, FEE_RATE).unwrap();
 }
 
@@ -213,17 +192,16 @@ fn test_omnilock_transfer_from_multisig() {
 
     let output = CellOutput::new_builder()
         .capacity((199 * ONE_CKB).pack())
-        .lock(receiver.clone())
+        .lock(sender.clone())
         .build();
     let builder = OmniLockTransferBuilder::new_open(
-        (1 * ONE_CKB).into(),
+        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 balancer = CapacityBalancer::new_simple(sender.clone(), placeholder_witness, ZERO_FEE_RATE);
 
     let mut cell_collector = ctx.to_live_cells_context();
     let account0_key = secp256k1::SecretKey::from_slice(ACCOUNT0_KEY.as_bytes()).unwrap();
@@ -306,7 +284,7 @@ fn test_omnilock_transfer_from_multisig() {
     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 );
+    assert!(receiver_capacity - 400 * ONE_CKB < ONE_CKB);
     let witnesses = tx
         .witnesses()
         .into_iter()
@@ -316,3 +294,173 @@ fn test_omnilock_transfer_from_multisig() {
     assert_eq!(witnesses[1].len(), placeholder_witness.as_slice().len());
     ctx.verify(tx, FEE_RATE).unwrap();
 }
+
+#[test]
+fn test_omnilock_transfer_from_sighash_absolute_from_start() {
+    test_omnilock_transfer_from_sighash_absolute(true);
+}
+#[test]
+fn test_omnilock_transfer_from_sighash_absolute_self() {
+    test_omnilock_transfer_from_sighash_absolute(false);
+}
+fn test_omnilock_transfer_from_sighash_absolute(from_start: bool) {
+    let cfgs: Vec<OmniLockConfig> = [ACCOUNT0_KEY, ACCOUNT2_KEY]
+        .iter()
+        .map(|key| {
+            let priv_key = secp256k1::SecretKey::from_slice(key.as_bytes())
+                .map_err(|err| format!("invalid sender secret key: {}", err))
+                .unwrap();
+            let pubkey = secp256k1::PublicKey::from_secret_key(&SECP256K1, &priv_key);
+            OmniLockConfig::new_pubkey_hash(blake160(&pubkey.serialize()))
+        })
+        .collect();
+    test_omnilock_simple_hash_absolute(cfgs[0].clone(), cfgs[1].clone(), from_start);
+}
+
+#[test]
+fn test_omnilock_transfer_from_ethereum_absolute_from_start() {
+    test_omnilock_transfer_from_ethereum_absolute(true);
+}
+#[test]
+fn test_omnilock_transfer_from_ethereum_absolute_from_self() {
+    test_omnilock_transfer_from_ethereum_absolute(false);
+}
+fn test_omnilock_transfer_from_ethereum_absolute(from_start: bool) {
+    let cfgs: Vec<OmniLockConfig> = [ACCOUNT0_KEY, ACCOUNT2_KEY]
+        .iter()
+        .map(|key| {
+            let priv_key = secp256k1::SecretKey::from_slice(key.as_bytes()).unwrap();
+            let pubkey = secp256k1::PublicKey::from_secret_key(&SECP256K1, &priv_key);
+            OmniLockConfig::new_ethereum(keccak160(Pubkey::from(pubkey).as_ref()))
+        })
+        .collect();
+    test_omnilock_simple_hash_absolute(cfgs[0].clone(), cfgs[1].clone(), from_start);
+}
+
+/// account0(200) => account0(exchange 199) + open pay 1,
+/// account2(100) => account2(101 - transaction fee)
+fn test_omnilock_simple_hash_absolute(
+    mut sender_cfg: OmniLockConfig,
+    mut receiver_cfg: OmniLockConfig,
+    from_start: bool,
+) {
+    sender_cfg.set_opentx_mode();
+    receiver_cfg.set_opentx_mode();
+    let unlock_mode = OmniUnlockMode::Normal;
+    let sender = build_omnilock_script(&sender_cfg);
+    let receiver = build_omnilock_script(&receiver_cfg);
+
+    let ctx = init_context(
+        vec![(OMNILOCK_BIN, true)],
+        vec![
+            (sender.clone(), Some(200 * ONE_CKB)),
+            (receiver.clone(), Some(100 * ONE_CKB)),
+            (receiver.clone(), Some(200 * ONE_CKB)),
+        ],
+    );
+
+    let output = CellOutput::new_builder()
+        .capacity((199 * ONE_CKB).pack())
+        .lock(sender.clone())
+        .build();
+    let builder = OmniLockTransferBuilder::new_open(
+        (ONE_CKB).into(),
+        vec![(output.clone(), Bytes::default())],
+        sender_cfg.clone(),
+        None,
+    );
+    let placeholder_witness = sender_cfg.placeholder_witness(unlock_mode).unwrap();
+    let balancer = CapacityBalancer::new_simple(sender.clone(), placeholder_witness, 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 unlockers = build_omnilock_unlockers(account0_key, sender_cfg.clone(), unlock_mode);
+    let mut tx = builder
+        .build_balanced(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
+        .unwrap();
+    let mut rng = rand::thread_rng();
+    let salt: u32 = rng.gen();
+    let wit = OpentxWitness::new_sig_all_absolute(&tx, Some(salt)).unwrap();
+    sender_cfg.set_opentx_input(wit);
+    tx = OmniLockTransferBuilder::update_opentx_witness(
+        tx,
+        &sender_cfg,
+        OmniUnlockMode::Normal,
+        &ctx,
+        &sender,
+    )
+    .unwrap();
+    // config updated, so unlockers must rebuilt.
+    let unlockers = build_omnilock_unlockers(account0_key, sender_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;
+
+    // use the opentx
+    let opentx_input_len = tx.inputs().len();
+    let opentx_output_len = tx.outputs().len();
+    receiver_cfg.set_opentx_reserve_bytes_by_commands(20);
+    // Build ScriptUnlocker
+    let account2_key = secp256k1::SecretKey::from_slice(ACCOUNT2_KEY.as_bytes()).unwrap();
+    let unlockers = build_omnilock_unlockers(account2_key, receiver_cfg.clone(), unlock_mode);
+
+    // Build CapacityBalancer
+    let placeholder_witness = receiver_cfg.placeholder_witness(unlock_mode).unwrap();
+    // why + 100? After update openwitness input list, will need tens of bytes more, if not +100, after update, should calculate adjust the fee again.
+    // If adjust the transaction fee later, the exchange may mot be enough to maintain the minimal capacity.
+    let balancer = CapacityBalancer::new_simple(receiver.clone(), placeholder_witness, FEE_RATE);
+
+    let builder = CapacityTransferBuilderWithTransaction::new(
+        vec![/*(output.clone(), Bytes::default())*/],
+        tx,
+    );
+    let mut tx = builder
+        .build_balanced(&mut cell_collector, &ctx, &ctx, &ctx, &balancer, &unlockers)
+        .unwrap();
+    assert_eq!(opentx_input_len + 1, tx.inputs().len());
+    assert_eq!(opentx_output_len + 1, tx.outputs().len());
+
+    let mut rng = rand::thread_rng();
+    let salt: u32 = rng.gen();
+    let mut wit = if from_start {
+        OpentxWitness::new_sig_all_absolute(&tx, Some(salt))
+    } else {
+        OpentxWitness::new_sig_to_end_absolute(&tx, Some(salt), opentx_input_len, opentx_output_len)
+    }
+    .unwrap(); //OpentxWitness::new_sig_all_absolute(&tx, Some(salt)).unwrap();
+    wit.add_tx_hash_input();
+    receiver_cfg.set_opentx_input(wit);
+
+    tx = OmniLockTransferBuilder::update_opentx_witness(
+        tx,
+        &receiver_cfg,
+        OmniUnlockMode::Normal,
+        &ctx,
+        &receiver,
+    )
+    .unwrap();
+
+    // config updated, so unlockers must rebuilt.
+    let unlockers = build_omnilock_unlockers(account2_key, receiver_cfg.clone(), unlock_mode);
+    let (new_tx, new_locked_groups) = unlock_tx(tx.clone(), &ctx, &unlockers).unwrap();
+
+    assert_eq!(1, new_locked_groups.len());
+    tx = new_tx;
+
+    println!(
+        "> tx: {}",
+        serde_json::to_string_pretty(&json_types::TransactionView::from(tx.clone())).unwrap()
+    );
+
+    assert_eq!(tx.header_deps().len(), 0);
+    assert_eq!(tx.cell_deps().len(), 1);
+    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 - 100 * ONE_CKB < ONE_CKB);
+    assert_eq!(tx.witnesses().len(), 2);
+    ctx.verify(tx, FEE_RATE).unwrap();
+}

src/tx_builder/omni_lock.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashSet, HashMap};
+use std::collections::{HashMap, HashSet};
 
 use ckb_types::{
     bytes::Bytes,
@@ -8,7 +8,9 @@ use ckb_types::{
     H256,
 };
 
-use super::{TxBuilder, TxBuilderError, CapacityBalancer, fill_placeholder_witnesses, balance_tx_capacity};
+use super::{
+    balance_tx_capacity, fill_placeholder_witnesses, CapacityBalancer, TxBuilder, TxBuilderError,
+};
 use crate::{
     traits::{CellCollector, CellDepResolver, HeaderDepResolver, TransactionDependencyProvider},
     unlock::{omni_lock::ConfigError, OmniLockConfig, OmniUnlockMode, ScriptUnlocker},

src/tx_builder/transfer.rs

@@ -58,16 +58,21 @@ impl TxBuilder for CapacityTransferBuilder {
     }
 }
 
-
 /// It's like CapacityTransferBuilder, except with a predefined transaction, it can be used when an open transaction is avaiable.
 pub struct CapacityTransferBuilderWithTransaction {
     pub outputs: Vec<(CellOutput, Bytes)>,
     pub transaction: TransactionView,
 }
 
 impl CapacityTransferBuilderWithTransaction {
-    pub fn new(outputs: Vec<(CellOutput, Bytes)>, transaction: TransactionView) -> CapacityTransferBuilderWithTransaction {
-        CapacityTransferBuilderWithTransaction { outputs, transaction }
+    pub fn new(
+        outputs: Vec<(CellOutput, Bytes)>,
+        transaction: TransactionView,
+    ) -> CapacityTransferBuilderWithTransaction {
+        CapacityTransferBuilderWithTransaction {
+            outputs,
+            transaction,
+        }
     }
 }
 
@@ -96,11 +101,12 @@ impl TxBuilder for CapacityTransferBuilderWithTransaction {
                 }
             }
         }
-        Ok(self.transaction.as_advanced_builder()
+        Ok(self
+            .transaction
+            .as_advanced_builder()
             .cell_deps(cell_deps)
             .outputs(outputs)
             .outputs_data(outputs_data)
             .build())
     }
 }
-