Upgrade multisig

Signed-off-by: Eval EXEC <execvy@gmail.com>

Author: eval-exec

examples/send_ckb_multisig_example.rs

@@ -25,14 +25,16 @@ fn main() -> Result<(), Box<dyn StdErr>> {
         2,
     )?;
     let sender = multisig_config.to_address(network_info.network_type, None);
+    println!("sender: {}", sender);
     let receiver = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r")?;
 
     let iterator = InputIterator::new_with_address(&[sender], &network_info);
     let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
-    builder.add_output(&receiver, Capacity::shannons(510_0000_0000u64));
+    builder.add_output(&receiver, Capacity::shannons(6100000000u64));
 
     let mut tx_with_groups =
         builder.build(&HandlerContexts::new_multisig(multisig_config.clone()))?;
+    println!("tx_with_groups:{:?}", &tx_with_groups);
 
     let json_tx = ckb_jsonrpc_types::TransactionView::from(tx_with_groups.get_tx_view().clone());
     println!("tx: {}", serde_json::to_string_pretty(&json_tx).unwrap());

examples/transfer_from_multisig.rs

@@ -6,7 +6,7 @@ use std::path::PathBuf;
 use ckb_hash::blake2b_256;
 use ckb_jsonrpc_types as json_types;
 use ckb_sdk::{
-    constants::{MULTISIG_TYPE_HASH, SIGHASH_TYPE_HASH},
+    constants::{MULTISIG_SCRIPT, SIGHASH_TYPE_HASH},
     rpc::CkbRpcClient,
     traits::{
         DefaultCellCollector, DefaultCellDepResolver, DefaultHeaderDepResolver,
@@ -222,8 +222,8 @@ fn build_transfer_tx(
 ) -> Result<TransactionView, Box<dyn StdErr>> {
     // Build CapacityBalancer
     let sender = Script::new_builder()
-        .code_hash(MULTISIG_TYPE_HASH.pack())
-        .hash_type(ScriptHashType::Type.into())
+        .code_hash(MULTISIG_SCRIPT.code_hash.pack())
+        .hash_type(MULTISIG_SCRIPT.hash_type.into())
         .args(Bytes::from(multisig_config.hash160().as_bytes().to_vec()).pack())
         .build();
     let sender_addr = Address::new(args.receiver.network(), sender.clone().into(), true);
@@ -289,7 +289,7 @@ fn build_multisig_unlockers(
     let signer = SecpCkbRawKeySigner::new_with_secret_keys(keys);
     let multisig_signer = SecpMultisigScriptSigner::new(Box::new(signer), config);
     let multisig_unlocker = SecpMultisigUnlocker::new(multisig_signer);
-    let multisig_script_id = ScriptId::new_type(MULTISIG_TYPE_HASH.clone());
+    let multisig_script_id = MULTISIG_SCRIPT;
     let mut unlockers = HashMap::default();
     unlockers.insert(
         multisig_script_id,

src/constants.rs

@@ -1,5 +1,7 @@
 use ckb_types::{core::EpochNumberWithFraction, h256, H256};
 
+use crate::ScriptId;
+
 pub const PREFIX_MAINNET: &str = "ckb";
 pub const PREFIX_TESTNET: &str = "ckt";
 
@@ -35,8 +37,35 @@ pub const TYPE_ID_CODE_HASH: H256 = h256!("0x545950455f4944");
 
 pub const SIGHASH_TYPE_HASH: H256 =
     h256!("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8");
-pub const MULTISIG_TYPE_HASH: H256 =
-    h256!("0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8");
+
+pub const GENESIS_BLOCK_HASH_MAINNET: H256 =
+    h256!("0x92b197aa1fba0f63633922c61c92375c9c074a93e85963554f5499fe1450d0e5");
+
+pub const GENESIS_BLOCK_HASH_TESTNET: H256 =
+    h256!("0x10639e0895502b5688a6be8cf69460d76541bfa4821629d86d62ba0aae3f9606");
+
+/// Depreacted MultiSig: HashType: type
+pub const MULTISIG_SCRIPT_DEPRECATED: ScriptId = ScriptId::new_type(h256!(
+    "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8"
+));
+
+/// MultiSig: HashType: data1,
+pub const MULTISIG_SCRIPT: ScriptId = ScriptId::new_data1(h256!(
+    "0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29"
+));
+
+/// https://github.com/nervosnetwork/ckb-system-scripts/pull/99#issuecomment-2814285588
+pub const MULTISIG_DEP_GROUP_MAINNET: (H256, u32) = (
+    h256!("0x6888aa39ab30c570c2c30d9d5684d3769bf77265a7973211a3c087fe8efbf738"),
+    0,
+);
+
+/// https://github.com/nervosnetwork/ckb-system-scripts/pull/99#issuecomment-2757175017
+pub const MULTISIG_DEP_GROUP_TESTNET: (H256, u32) = (
+    h256!("0x2eefdeb21f3a3edf697c28a52601b4419806ed60bb427420455cc29a090b26d5"),
+    0,
+);
+
 pub const DAO_TYPE_HASH: H256 =
     h256!("0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e");
 

src/test_util.rs

@@ -9,11 +9,9 @@ use ckb_types::core::{HeaderBuilder, TransactionBuilder};
 use rand::{thread_rng, Rng};
 use thiserror::Error;
 
+use crate::constants::MULTISIG_SCRIPT;
 use crate::{
-    constants::{
-        MULTISIG_GROUP_OUTPUT_LOC, MULTISIG_TYPE_HASH, ONE_CKB, SIGHASH_GROUP_OUTPUT_LOC,
-        SIGHASH_TYPE_HASH,
-    },
+    constants::{MULTISIG_GROUP_OUTPUT_LOC, ONE_CKB, SIGHASH_GROUP_OUTPUT_LOC, SIGHASH_TYPE_HASH},
     traits::{
         CellCollector, CellCollectorError, CellDepResolver, CellQueryOptions,
         DefaultCellDepResolver, HeaderDepResolver, LiveCell, TransactionDependencyError,
@@ -99,18 +97,15 @@ impl Context {
             let (output, data) = tx.output_with_data(output_idx).expect("get output+data");
             ctx.add_cell_dep(cell_dep, output, data, Some(block_hash.clone()));
         }
-        for (code_hash, cell_dep) in [
-            (
-                SIGHASH_TYPE_HASH,
-                cell_dep_resolver.sighash_dep().unwrap().0.clone(),
-            ),
-            (
-                MULTISIG_TYPE_HASH,
-                cell_dep_resolver.multisig_dep().unwrap().0.clone(),
-            ),
-        ] {
-            ctx.add_cell_dep_map(ScriptId::new_type(code_hash), cell_dep);
-        }
+        ctx.add_cell_dep_map(
+            ScriptId::new_type(SIGHASH_TYPE_HASH),
+            cell_dep_resolver.sighash_dep().unwrap().0.clone(),
+        );
+
+        ctx.add_cell_dep_map(
+            MULTISIG_SCRIPT,
+            cell_dep_resolver.sighash_dep().unwrap().0.clone(),
+        );
         for tx in block.transactions().iter() {
             for (idx, (output, data)) in tx
                 .outputs()

src/tests/mod.rs

@@ -1,19 +1,7 @@
 use std::collections::HashMap;
 
-use ckb_dao_utils::pack_dao_data;
-use ckb_hash::blake2b_256;
-use ckb_jsonrpc_types as json_types;
-use ckb_types::{
-    bytes::Bytes,
-    core::{BlockView, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType},
-    h160, h256,
-    packed::{CellInput, CellOutput, Script, ScriptOpt, WitnessArgs},
-    prelude::*,
-    H160, H256,
-};
-
 use crate::constants::{
-    CHEQUE_CELL_SINCE, DAO_TYPE_HASH, MULTISIG_TYPE_HASH, ONE_CKB, SIGHASH_TYPE_HASH,
+    CHEQUE_CELL_SINCE, DAO_TYPE_HASH, MULTISIG_SCRIPT, ONE_CKB, SIGHASH_TYPE_HASH,
 };
 use crate::traits::SecpCkbRawKeySigner;
 use crate::tx_builder::{
@@ -33,6 +21,17 @@ use crate::unlock::{
 };
 use crate::util::{calculate_dao_maximum_withdraw4, minimal_unlock_point};
 use crate::{ScriptId, Since, SinceType};
+use ckb_dao_utils::pack_dao_data;
+use ckb_hash::blake2b_256;
+use ckb_jsonrpc_types as json_types;
+use ckb_types::{
+    bytes::Bytes,
+    core::{BlockView, Capacity, EpochNumberWithFraction, HeaderBuilder, ScriptHashType},
+    h160, h256,
+    packed::{CellInput, CellOutput, Script, ScriptOpt, WitnessArgs},
+    prelude::*,
+    H160, H256,
+};
 
 use crate::test_util::{random_out_point, Context};
 
@@ -73,8 +72,8 @@ fn build_sighash_script(args: H160) -> Script {
 
 fn build_multisig_script(cfg: &MultisigConfig) -> Script {
     Script::new_builder()
-        .code_hash(MULTISIG_TYPE_HASH.pack())
-        .hash_type(ScriptHashType::Type.into())
+        .code_hash(MULTISIG_SCRIPT.code_hash.pack())
+        .hash_type(MULTISIG_SCRIPT.hash_type.into())
         .args(Bytes::from(cfg.hash160().0.to_vec()).pack())
         .build()
 }
@@ -105,7 +104,7 @@ fn build_multisig_unlockers(
 ) -> HashMap<ScriptId, Box<dyn ScriptUnlocker>> {
     let signer = SecpCkbRawKeySigner::new_with_secret_keys(vec![key]);
     let multisig_unlocker = SecpMultisigUnlocker::from((Box::new(signer) as Box<_>, config));
-    let multisig_script_id = ScriptId::new_type(MULTISIG_TYPE_HASH.clone());
+    let multisig_script_id = MULTISIG_SCRIPT;
     let mut unlockers = HashMap::default();
     unlockers.insert(
         multisig_script_id,
@@ -219,8 +218,16 @@ fn test_transfer_from_multisig() {
     let sender = build_multisig_script(&cfg);
     let receiver = build_sighash_script(ACCOUNT2_ARG);
 
+    // The multisig contract is not in the genesis block, so we need to add it to the context.
+    // xxd -p -c 0 /home/exec/.cargo/git/checkouts/ckb-system-scripts-b6291a7e08e07936/d262955/specs/cells/secp256k1_blake160_multisig_all > src/tests/secp256k1_blake160_multisig_all.hex.txt
+    let multisig_contract =
+        std::fs::read_to_string("./src/tests/secp256k1_blake160_multisig_all.hex.txt").unwrap();
+    let multisig_contract = multisig_contract.trim();
+    let contract = hex::decode(multisig_contract).unwrap();
+
+    let contract: (&[u8], bool) = (contract.as_slice(), true);
     let ctx = init_context(
-        Vec::new(),
+        vec![contract],
         vec![
             (sender.clone(), Some(100 * ONE_CKB)),
             (sender.clone(), Some(200 * ONE_CKB)),
@@ -258,6 +265,7 @@ fn test_transfer_from_multisig() {
     assert_eq!(tx.cell_deps().len(), 1);
     assert_eq!(tx.inputs().len(), 2);
     for out_point in tx.input_pts_iter() {
+        dbg!(&out_point);
         assert_eq!(ctx.get_input(&out_point).unwrap().0.lock(), sender);
     }
     assert_eq!(tx.outputs().len(), 2);
@@ -271,6 +279,10 @@ fn test_transfer_from_multisig() {
     assert_eq!(witnesses.len(), 2);
     assert_eq!(witnesses[0].len(), placeholder_witness.as_slice().len());
     assert_eq!(witnesses[1].len(), 0);
+    tx.inputs().into_iter().for_each(|input| {
+        dbg!(&input);
+    });
+    dbg!(&tx);
     ctx.verify(tx, FEE_RATE).unwrap();
 }
 

src/tests/secp256k1_blake160_multisig_all.hex.txt

@@ -23,24 +23,32 @@ use super::{
     OffchainTransactionDependencyProvider,
 };
 use crate::rpc::ckb_indexer::{Order, SearchKey, Tip};
-use crate::rpc::{CkbRpcAsyncClient, IndexerRpcAsyncClient};
-use crate::traits::{
-    CellCollector, CellCollectorError, CellDepResolver, CellQueryOptions, HeaderDepResolver,
-    LiveCell, QueryOrder, Signer, SignerError, TransactionDependencyError,
-    TransactionDependencyProvider,
-};
-use crate::types::ScriptId;
 use crate::util::{get_max_mature_number_async, serialize_signature, zeroize_privkey};
 use crate::SECP256K1;
+use crate::{
+    constants::GENESIS_BLOCK_HASH_MAINNET,
+    rpc::{CkbRpcAsyncClient, IndexerRpcAsyncClient},
+};
+use crate::{constants::MULTISIG_SCRIPT, types::ScriptId};
 use crate::{
     constants::{
-        DAO_OUTPUT_LOC, DAO_TYPE_HASH, MULTISIG_GROUP_OUTPUT_LOC, MULTISIG_OUTPUT_LOC,
-        MULTISIG_TYPE_HASH, SIGHASH_GROUP_OUTPUT_LOC, SIGHASH_OUTPUT_LOC, SIGHASH_TYPE_HASH,
+        DAO_OUTPUT_LOC, DAO_TYPE_HASH, SIGHASH_GROUP_OUTPUT_LOC, SIGHASH_OUTPUT_LOC,
+        SIGHASH_TYPE_HASH,
     },
     util::keccak160,
 };
+use crate::{
+    constants::{
+        GENESIS_BLOCK_HASH_TESTNET, MULTISIG_DEP_GROUP_MAINNET, MULTISIG_DEP_GROUP_TESTNET,
+    },
+    traits::{
+        CellCollector, CellCollectorError, CellDepResolver, CellQueryOptions, HeaderDepResolver,
+        LiveCell, QueryOrder, Signer, SignerError, TransactionDependencyError,
+        TransactionDependencyProvider,
+    },
+};
 use ckb_resource::{
-    CODE_HASH_DAO, CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
+    CODE_HASH_DAO, // CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
     CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL,
 };
 
@@ -69,7 +77,7 @@ impl DefaultCellDepResolver {
             return Err(ParseGenesisInfoError::InvalidBlockNumber(header.number()));
         }
         let mut sighash_type_hash = None;
-        let mut multisig_type_hash = None;
+        // let mut multisig_type_hash = None;
         let mut dao_type_hash = None;
         let out_points = genesis_block
             .transactions()
@@ -95,20 +103,20 @@ impl DefaultCellDepResolver {
                                 );
                             }
                         }
-                        if tx_index == MULTISIG_OUTPUT_LOC.0 && index == MULTISIG_OUTPUT_LOC.1 {
-                            multisig_type_hash = output
-                                .type_()
-                                .to_opt()
-                                .map(|script| script.calc_script_hash());
-                            let data_hash = CellOutput::calc_data_hash(&data.raw_data());
-                            if data_hash != CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL.pack() {
-                                log::error!(
-                                    "System multisig script code hash error! found: {}, expected: {}",
-                                    data_hash,
-                                    CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
-                                );
-                            }
-                        }
+                        // if tx_index == MULTISIG_OUTPUT_LOC.0 && index == MULTISIG_OUTPUT_LOC.1 {
+                        //     multisig_type_hash = output
+                        //         .type_()
+                        //         .to_opt()
+                        //         .map(|script| script.calc_script_hash());
+                        //     let data_hash = CellOutput::calc_data_hash(&data.raw_data());
+                        //     if data_hash != CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL.pack() {
+                        //         log::error!(
+                        //             "System multisig script code hash error! found: {}, expected: {}",
+                        //             data_hash,
+                        //             CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
+                        //         );
+                        //     }
+                        // }
                         if tx_index == DAO_OUTPUT_LOC.0 && index == DAO_OUTPUT_LOC.1 {
                             dao_type_hash = output
                                 .type_()
@@ -132,9 +140,6 @@ impl DefaultCellDepResolver {
         let sighash_type_hash = sighash_type_hash
             .ok_or_else(|| "No type hash(sighash) found in txs[0][1]".to_owned())
             .map_err(ParseGenesisInfoError::TypeHashNotFound)?;
-        let multisig_type_hash = multisig_type_hash
-            .ok_or_else(|| "No type hash(multisig) found in txs[0][4]".to_owned())
-            .map_err(ParseGenesisInfoError::TypeHashNotFound)?;
         let dao_type_hash = dao_type_hash
             .ok_or_else(|| "No type hash(dao) found in txs[0][2]".to_owned())
             .map_err(ParseGenesisInfoError::TypeHashNotFound)?;
@@ -143,10 +148,34 @@ impl DefaultCellDepResolver {
             .out_point(out_points[SIGHASH_GROUP_OUTPUT_LOC.0][SIGHASH_GROUP_OUTPUT_LOC.1].clone())
             .dep_type(DepType::DepGroup.into())
             .build();
-        let multisig_dep = CellDep::new_builder()
-            .out_point(out_points[MULTISIG_GROUP_OUTPUT_LOC.0][MULTISIG_GROUP_OUTPUT_LOC.1].clone())
-            .dep_type(DepType::DepGroup.into())
-            .build();
+
+        let multisig_dep = if genesis_block.hash().eq(&GENESIS_BLOCK_HASH_MAINNET.pack()) {
+            // mainnet
+            CellDep::new_builder()
+                .out_point(
+                    ckb_types::packed::OutPoint::new_builder()
+                        .tx_hash(MULTISIG_DEP_GROUP_MAINNET.0.pack())
+                        .index(MULTISIG_DEP_GROUP_MAINNET.1.pack())
+                        .build(),
+                )
+                .dep_type(DepType::DepGroup.into())
+                .build()
+        } else if genesis_block.hash().eq(&GENESIS_BLOCK_HASH_TESTNET.pack()) {
+            // testnet
+            CellDep::new_builder()
+                .out_point(
+                    ckb_types::packed::OutPoint::new_builder()
+                        .tx_hash(MULTISIG_DEP_GROUP_TESTNET.0.pack())
+                        .index(MULTISIG_DEP_GROUP_TESTNET.1.pack())
+                        .build(),
+                )
+                .dep_type(DepType::DepGroup.into())
+                .build()
+        } else {
+            //dev net
+            unimplemented!()
+        };
+
         let dao_dep = CellDep::new_builder()
             .out_point(out_points[DAO_OUTPUT_LOC.0][DAO_OUTPUT_LOC.1].clone())
             .build();
@@ -157,7 +186,7 @@ impl DefaultCellDepResolver {
             (sighash_dep, "Secp256k1 blake160 sighash all".to_string()),
         );
         items.insert(
-            ScriptId::new_type(multisig_type_hash.unpack()),
+            MULTISIG_SCRIPT,
             (multisig_dep, "Secp256k1 blake160 multisig all".to_string()),
         );
         items.insert(
@@ -188,7 +217,7 @@ impl DefaultCellDepResolver {
         self.get(&ScriptId::new_type(SIGHASH_TYPE_HASH))
     }
     pub fn multisig_dep(&self) -> Option<&(CellDep, String)> {
-        self.get(&ScriptId::new_type(MULTISIG_TYPE_HASH))
+        self.get(&MULTISIG_SCRIPT)
     }
     pub fn dao_dep(&self) -> Option<&(CellDep, String)> {
         self.get(&ScriptId::new_type(DAO_TYPE_HASH))