Upgrade multisig

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

Author: eval-exec

Cargo.toml

@@ -38,11 +38,14 @@ ckb-traits = "0.200.0"
 ckb-jsonrpc-types = "0.200.0"
 ckb-hash = "0.200.0"
 ckb-resource = "0.200.0"
+ckb-system-scripts-v0_5_4 = { package="ckb-system-scripts", version="=0.5.4" }
+ckb-system-scripts-v0_6_0 = { package="ckb-system-scripts", version="=0.6.0" }
 ckb-crypto = { version = "=0.200.0", features = ["secp"] }
 ckb-script = "0.200.0"
 bitflags = "1.3.2"
 sha3 = "0.10.1"
 enum-repr-derive = "0.2.0"
+hex = "0.4"
 
 # for feature test
 rand = { version = "0.7.3", optional = true }
@@ -61,4 +64,4 @@ test = []
 [dev-dependencies]
 clap = { version = "4.4.18", features = ["derive"] }
 httpmock = "0.6"
-hex = "0.4"
+tempfile = "3.19.1"

examples/send_ckb_multisig_example.rs

@@ -1,4 +1,5 @@
 use ckb_sdk::{
+    constants::MultisigScript,
     transaction::{
         builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
         handler::HandlerContexts,
@@ -17,22 +18,25 @@ fn main() -> Result<(), Box<dyn StdErr>> {
     let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
 
     let multisig_config = MultisigConfig::new_with(
+        MultisigScript::V1,
         vec![
             h160!("0x7336b0ba900684cb3cb00f0d46d4f64c0994a562"),
             h160!("0x5724c1e3925a5206944d753a6f3edaedf977d77f"),
         ],
         0,
         2,
     )?;
-    let sender = multisig_config.to_address(network_info.network_type, None);
+    let sender = multisig_config.to_address(network_info.network_type, MultisigScript::V1, 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::{MultisigScript, SIGHASH_TYPE_HASH},
     rpc::CkbRpcClient,
     traits::{
         DefaultCellCollector, DefaultCellDepResolver, DefaultHeaderDepResolver,
@@ -144,7 +144,12 @@ fn main() -> Result<(), Box<dyn StdErr>> {
                     }
                     sighash_addresses.push(H160::from_slice(lock_args.as_ref()).unwrap());
                 }
-                MultisigConfig::new_with(sighash_addresses, args.require_first_n, args.threshold)?
+                MultisigConfig::new_with(
+                    ckb_sdk::constants::MultisigScript::V1,
+                    sighash_addresses,
+                    args.require_first_n,
+                    args.threshold,
+                )?
             };
             let tx = build_transfer_tx(&args, &multisig_config)?;
             let tx_info = TxInfo {
@@ -222,8 +227,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(MultisigScript::V1.script_id().code_hash.pack())
+        .hash_type(MultisigScript::V1.script_id().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 +294,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 = MultisigScript::V1.script_id();
     let mut unlockers = HashMap::default();
     unlockers.insert(
         multisig_script_id,

examples/transfer_from_omnilock_multisig.rs

@@ -1,6 +1,6 @@
 use ckb_jsonrpc_types as json_types;
 use ckb_sdk::{
-    constants::SIGHASH_TYPE_HASH,
+    constants::{MultisigScript, SIGHASH_TYPE_HASH},
     rpc::CkbRpcClient,
     traits::{
         DefaultCellCollector, DefaultCellDepResolver, DefaultHeaderDepResolver,
@@ -11,8 +11,10 @@ use ckb_sdk::{
         unlock_tx, CapacityBalancer, TxBuilder,
     },
     types::NetworkType,
-    unlock::{MultisigConfig, OmniLockUnlocker, ScriptUnlocker},
-    unlock::{OmniLockConfig, OmniLockScriptSigner, OmniUnlockMode},
+    unlock::{
+        MultisigConfig, OmniLockConfig, OmniLockScriptSigner, OmniLockUnlocker, OmniUnlockMode,
+        ScriptUnlocker,
+    },
     Address, HumanCapacity, ScriptGroup, ScriptId,
 };
 use ckb_types::{
@@ -272,6 +274,7 @@ fn build_multisig_config(
         sighash_addresses.push(H160::from_slice(lock_args.as_ref()).unwrap());
     }
     Ok(MultisigConfig::new_with(
+        MultisigScript::V1,
         sighash_addresses,
         require_first_n,
         threshold,

src/constants.rs

@@ -1,4 +1,18 @@
-use ckb_types::{core::EpochNumberWithFraction, h256, H256};
+use std::convert::TryFrom;
+
+use crate::{CkbRpcClient, NetworkInfo, NetworkType, ScriptId};
+use ckb_system_scripts_v0_5_4::{
+    CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL as CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_LEGACY,
+    CODE_HASH_SECP256K1_DATA,
+};
+use ckb_system_scripts_v0_6_0::CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL as CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_V1;
+use ckb_types::{
+    core::EpochNumberWithFraction,
+    h256,
+    packed::{Byte32, CellOutput, OutPoint, OutPointVecReader},
+    prelude::*,
+    H256,
+};
 
 pub const PREFIX_MAINNET: &str = "ckb";
 pub const PREFIX_TESTNET: &str = "ckt";
@@ -19,10 +33,10 @@ pub const REMAIN_FLAGS_BITS: u64 = 0x1f00_0000_0000_0000;
 
 // Special cells in genesis transactions: (transaction-index, output-index)
 pub const SIGHASH_OUTPUT_LOC: (usize, usize) = (0, 1);
-pub const MULTISIG_OUTPUT_LOC: (usize, usize) = (0, 4);
+pub const MULTISIG_LEGACY_OUTPUT_LOC: (usize, usize) = (0, 4);
 pub const DAO_OUTPUT_LOC: (usize, usize) = (0, 2);
 pub const SIGHASH_GROUP_OUTPUT_LOC: (usize, usize) = (1, 0);
-pub const MULTISIG_GROUP_OUTPUT_LOC: (usize, usize) = (1, 1);
+pub const MULTISIG_LEGACY_GROUP_OUTPUT_LOC: (usize, usize) = (1, 1);
 
 pub const ONE_CKB: u64 = 100_000_000;
 pub const MIN_SECP_CELL_CAPACITY: u64 = 61 * ONE_CKB;
@@ -35,8 +49,13 @@ 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");
+
 pub const DAO_TYPE_HASH: H256 =
     h256!("0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e");
 
@@ -51,13 +70,182 @@ pub const ACP_TYPE_HASH_AGGRON: H256 =
 /// cheque withdraw since value
 pub const CHEQUE_CELL_SINCE: u64 = 0xA000000000000006;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MultisigScript {
+    /// Multisig Script deployed on Genesis Block
+    /// https://explorer.nervos.org/script/0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8/type
+    Legacy,
+
+    /// Latest multisig script
+    /// https://explorer.nervos.org/script/0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29/data1
+    V1,
+}
+
+impl MultisigScript {
+    pub const fn script_id(&self) -> ScriptId {
+        match self {
+            MultisigScript::Legacy => ScriptId::new_type(h256!(
+                "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8"
+            )),
+            MultisigScript::V1 => ScriptId::new_data1(h256!(
+                "0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29"
+            )),
+        }
+    }
+
+    fn dep_group_from_env(&self, _network: NetworkInfo) -> Option<(H256, u32)> {
+        let env_dep_group = match self {
+            MultisigScript::Legacy => std::env::var("MULTISIG_LEGACY_DEP_GROUP"),
+            MultisigScript::V1 => std::env::var("MULTISIG_V1_DEP_GROUP"),
+        }
+        .ok()?;
+
+        let vars = env_dep_group.split(",").collect::<Vec<_>>();
+        match (vars.first(), vars.get(1)) {
+            (Some(hash), Some(index)) => {
+                let index_u32: u32 = index.parse().ok()?;
+
+                if !hash.starts_with("0x") {
+                    return None;
+                }
+                let hash_bytes = hex::decode(&hash[2..]).ok()?;
+
+                let hash = H256::from_slice(&hash_bytes).ok()?;
+                Some((hash, index_u32))
+            }
+            _ => None,
+        }
+    }
+
+    /// Get dep group from env first:
+    /// 1. MULTISIG_LEGACY_DEP_GROUP=0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c,1
+    /// 2. MULTISIG_V1_DEP_GROUP=0x6888aa39ab30c570c2c30d9d5684d3769bf77265a7973211a3c087fe8efbf738,2
+    ///
+    /// If env not set, then get it from dep_group_inner
+    pub fn dep_group(&self, network: NetworkInfo) -> Option<(H256, u32)> {
+        self.dep_group_from_env(network.clone())
+            .or(self.dep_group_inner(network))
+    }
+
+    pub fn dep_group_inner(&self, network: NetworkInfo) -> Option<(H256, u32)> {
+        match network.network_type {
+            NetworkType::Mainnet => Some(match self {
+                MultisigScript::Legacy => (
+                    h256!("0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c"),
+                    1,
+                ),
+                MultisigScript::V1 => (
+                    h256!("0x6888aa39ab30c570c2c30d9d5684d3769bf77265a7973211a3c087fe8efbf738"),
+                    0,
+                ),
+            }),
+            NetworkType::Testnet => Some(match self {
+                MultisigScript::Legacy => (
+                    h256!("0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37"),
+                    1,
+                ),
+                MultisigScript::V1 => (
+                    h256!("0x2eefdeb21f3a3edf697c28a52601b4419806ed60bb427420455cc29a090b26d5"),
+                    0,
+                ),
+            }),
+            NetworkType::Staging | NetworkType::Preview | NetworkType::Dev => {
+                let client = CkbRpcClient::new(network.url.as_str());
+                let json_genesis_block = client.get_block_by_number(0_u64.into()).ok()??;
+                let genesis_block: ckb_types::core::BlockView = json_genesis_block.into();
+
+                let secp256k1_data_outpoint =
+                    find_cell_match_data_hash(&genesis_block, CODE_HASH_SECP256K1_DATA.pack())?;
+
+                let target_data_hash = match self {
+                    MultisigScript::Legacy => {
+                        CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_LEGACY.pack()
+                    }
+                    MultisigScript::V1 => CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_V1.pack(),
+                };
+                let multisig_outpoint =
+                    find_cell_match_data_hash(&genesis_block, target_data_hash)?;
+
+                let (dep_hash, dep_index) = find_cell_match_data_hash_find_dep(
+                    &genesis_block,
+                    vec![secp256k1_data_outpoint, multisig_outpoint],
+                )?;
+
+                let dep_hash: H256 = dep_hash.unpack();
+                Some((dep_hash, dep_index))
+            }
+        }
+    }
+}
+
+fn find_cell_match_data_hash(
+    genesis_block: &ckb_types::core::BlockView,
+    target_data_hash: Byte32,
+) -> Option<OutPoint> {
+    genesis_block.transactions().iter().find_map(|tx| {
+        let multisig_legacy_cell_index =
+            tx.outputs_with_data_iter()
+                .enumerate()
+                .find_map(|(index, (_output, data))| {
+                    let data_hash = CellOutput::calc_data_hash(&data);
+                    data_hash.eq(&target_data_hash).then_some(index)
+                });
+        multisig_legacy_cell_index.map(|cell_index| OutPoint::new(tx.hash(), cell_index as u32))
+    })
+}
+
+fn find_cell_match_data_hash_find_dep(
+    genesis_block: &ckb_types::core::BlockView,
+    target_points: Vec<OutPoint>,
+) -> Option<(ckb_types::packed::Byte32, u32)> {
+    genesis_block.transactions().iter().find_map(|tx| {
+        let multisig_cell_index: Option<u32> =
+            tx.outputs_with_data_iter()
+                .enumerate()
+                .find_map(|(index, (_output, data))| {
+                    let he = hex_string(&data);
+                    if he.len() > 200 {
+                        return None;
+                    }
+                    let outpoint_vec = OutPointVecReader::from_slice(&data)
+                        .map(|reader| reader.to_entity())
+                        .ok()?;
+
+                    target_points
+                        .iter()
+                        .all(|target_point| {
+                            outpoint_vec
+                                .clone()
+                                .into_iter()
+                                .any(|outpoint| outpoint.eq(target_point))
+                        })
+                        .then_some(index as u32)
+                });
+
+        multisig_cell_index.map(|cell_index| (tx.hash(), cell_index))
+    })
+}
+
+impl TryFrom<H256> for MultisigScript {
+    type Error = ();
+
+    fn try_from(code_hash: H256) -> Result<Self, Self::Error> {
+        if code_hash.eq(&MultisigScript::Legacy.script_id().code_hash) {
+            Ok(MultisigScript::Legacy)
+        } else if code_hash.eq(&MultisigScript::V1.script_id().code_hash) {
+            Ok(MultisigScript::V1)
+        } else {
+            Err(())
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
     use ckb_types::{
         core::Capacity,
         packed::{CellOutput, Script},
-        prelude::*,
         H160,
     };
 
@@ -76,4 +264,39 @@ mod test {
 
         assert_eq!(min_secp_cell_capacity, MIN_SECP_CELL_CAPACITY);
     }
+
+    #[test]
+    fn test_multisig_deps() {
+        assert_ne!(
+            CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_LEGACY,
+            CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL_V1
+        );
+
+        let mainnet = NetworkInfo::mainnet();
+        assert!(MultisigScript::Legacy.dep_group(mainnet.clone()).is_some());
+        assert!(MultisigScript::V1.dep_group(mainnet).is_some());
+
+        let testnet = NetworkInfo::testnet();
+        assert!(MultisigScript::Legacy.dep_group(testnet.clone()).is_some());
+        assert!(MultisigScript::V1.dep_group(testnet).is_some());
+
+        // TODO: start ckb devchain in this unit test
+        // let devnet = NetworkInfo::devnet();
+        // assert!(MultisigScript::Legacy.dep_group(devnet.clone()).is_some());
+
+        // TODO, let ckb devnet deploy multisig_v1 on genesis block
+        // assert!(MultisigScript::V1.dep_group(devnet).is_some());
+    }
+
+    #[test]
+    fn test_dep_group_from_env() {
+        let legacy = MultisigScript::Legacy;
+        std::env::set_var(
+            "MULTISIG_LEGACY_DEP_GROUP",
+            "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c,10000",
+        );
+        let dep_group = legacy.dep_group_from_env(NetworkInfo::devnet());
+        assert!(dep_group.is_some());
+        assert_eq!(dep_group.unwrap().1, 10000)
+    }
 }