update

Signed-off-by: Eval EXEC <[email protected]>

Author: eval-exec

Cargo.lock

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use anyhow::{anyhow, Result};
 use ckb_sdk::{
-    constants::{MULTISIG_SCRIPT, SIGHASH_TYPE_HASH},
+    constants::{MultisigScript, SIGHASH_TYPE_HASH},
     traits::{
         CellCollector, CellQueryOptions, DefaultCellCollector, DefaultHeaderDepResolver,
         DefaultTransactionDependencyProvider, OffchainTransactionDependencyProvider, Signer,
@@ -79,10 +79,7 @@ pub fn build_tx<T: ChangeInfo>(
         .iter()
         .filter_map(|info| info.build_cell_output(lock_script, first_cell_input))
         .unzip();
-    let mut cell_deps = vec![genesis_info.sighash_dep()];
-    if multisig_config.is_some() {
-        cell_deps.push(genesis_info.multisig_dep());
-    }
+
     let mut unlockers = HashMap::new();
     let signer = DummySigner {
         args: vec![from_address.payload().args()],
@@ -93,10 +90,22 @@ pub fn build_tx<T: ChangeInfo>(
         sighash_script_id,
         Box::new(sighash_unlocker) as Box<dyn ScriptUnlocker>,
     );
+
+    let mut cell_deps = vec![genesis_info.sighash_dep()];
     if let Some(cfg) = multisig_config {
+        let multisig_script =
+            MultisigScript::try_from(cfg.lock_code_hash()).unwrap_or_else(|_err| {
+                panic!(
+                    "Failed to get multisig script from {}",
+                    cfg.lock_code_hash(),
+                )
+            });
+
+        cell_deps.push(genesis_info.multisig_dep(multisig_script));
+
         let multisig_signer = SecpMultisigScriptSigner::new(Box::new(signer), cfg.clone());
         let multisig_unlocker = SecpMultisigUnlocker::new(multisig_signer);
-        let multisig_script_id = MULTISIG_SCRIPT;
+        let multisig_script_id = multisig_script.script_id();
         unlockers.insert(
             multisig_script_id,
             Box::new(multisig_unlocker) as Box<dyn ScriptUnlocker>,

src/subcommands/deploy/tx_builder.rs

@@ -7,7 +7,7 @@ use std::str::FromStr;
 
 use ckb_jsonrpc_types as json_types;
 use ckb_jsonrpc_types::JsonBytes;
-use ckb_sdk::constants::{MultisigScript, MULTISIG_SCRIPT};
+use ckb_sdk::constants::MultisigScript;
 use ckb_sdk::{
     constants::SECP_SIGNATURE_SIZE, unlock::MultisigConfig, Address, AddressPayload, HumanCapacity,
     NetworkType,
@@ -74,8 +74,8 @@ impl<'a> TxSubCommand<'a> {
             .required(true)
             .validator(|input| AddressParser::new_sighash().validate(input))
             .about("Normal sighash address");
-        let arg_multisig_lock_hash = Arg::with_name("lock-code-hash")
-            .long("lock-code-hash")
+        let arg_multisig_lock_hash = Arg::with_name("multisig-code-hash")
+            .long("multisig-code-hash")
             .takes_value(true)
             .multiple(false)
             .required(false)
@@ -157,6 +157,7 @@ impl<'a> TxSubCommand<'a> {
                     .arg(arg_skip_check.clone()),
                 App::new("add-output")
                     .about("Add cell output")
+                    .arg(arg_multisig_lock_hash.clone())
                     .arg(
                         Arg::with_name("to-sighash-address")
                             .long("to-sighash-address")
@@ -173,14 +174,26 @@ impl<'a> TxSubCommand<'a> {
                             .long("to-short-multisig-address")
                             .conflicts_with("to-long-multisig-address")
                             .takes_value(true)
-                            .validator(|input| AddressParser::new_multisig().validate(input))
-                            .about("To short multisig address"),
+                            .requires("multisig-code-hash")
+                            .validator(|input| {
+                                AddressParser::new_multisig(MultisigScript::Legacy)
+                                    .validate(input)
+                                    .or(AddressParser::new_multisig(MultisigScript::V1)
+                                        .validate(input))
+                            })
+                            .about("To short multisig address(encode with lagacy multisig script)"),
                     )
                     .arg(
                         Arg::with_name("to-long-multisig-address")
                             .long("to-long-multisig-address")
                             .takes_value(true)
-                            .validator(|input| AddressParser::new_multisig().validate(input))
+                            .requires("multisig-code-hash")
+                            .validator(|input| {
+                                AddressParser::new_multisig(MultisigScript::Legacy)
+                                    .validate(input)
+                                    .or(AddressParser::new_multisig(MultisigScript::V1)
+                                        .validate(input))
+                            })
                             .about("To long multisig address (special case, include since)"),
                     )
                     .arg(arg::capacity().required(true))
@@ -322,12 +335,24 @@ impl CliSubCommand for TxSubCommand<'_> {
             ("add-output", Some(m)) => {
                 let tx_file: PathBuf = FilePathParser::new(true).from_matches(m, "tx-file")?;
                 let capacity: u64 = CapacityParser.from_matches(m, "capacity")?;
+
+                let multisig_lock_code_hash: H256 =
+                    FixedHashParser::<H256>::default().from_matches(m, "multisig-code-hash")?;
+                let multisig_script = MultisigScript::try_from(multisig_lock_code_hash.clone())
+                    .map_err(|_err| {
+                        format!(
+                            "invalid multisig lock code hash: {}",
+                            multisig_lock_code_hash
+                        )
+                    })?;
+
                 let to_sighash_address_opt: Option<Address> =
                     AddressParser::new_sighash().from_matches_opt(m, "to-sighash-address")?;
-                let to_short_multisig_address_opt: Option<Address> = AddressParser::new_multisig()
-                    .from_matches_opt(m, "to-short-multisig-address")?;
+                let to_short_multisig_address_opt: Option<Address> =
+                    AddressParser::new_multisig(multisig_script)
+                        .from_matches_opt(m, "to-short-multisig-address")?;
                 let to_long_multisig_address_opt: Option<Address> =
-                    AddressParser::new_multisig()
+                    AddressParser::new_multisig(multisig_script)
                         .from_matches_opt(m, "to-long-multisig-address")?;
 
                 let to_data = get_to_data(m)?;
@@ -370,7 +395,7 @@ impl CliSubCommand for TxSubCommand<'_> {
             }
             ("add-multisig-config", Some(m)) => {
                 let multisig_lock_code_hash: H256 =
-                    FixedHashParser::<H256>::default().from_matches(m, "lock-code-hash")?;
+                    FixedHashParser::<H256>::default().from_matches(m, "multisig-code-hash")?;
                 let multisig_script = MultisigScript::try_from(multisig_lock_code_hash.clone())
                     .map_err(|_err| {
                         format!(
@@ -597,7 +622,7 @@ impl CliSubCommand for TxSubCommand<'_> {
             }
             ("build-multisig-address", Some(m)) => {
                 let multisig_lock_code_hash: H256 =
-                    FixedHashParser::<H256>::default().from_matches(m, "lock-code-hash")?;
+                    FixedHashParser::<H256>::default().from_matches(m, "multisig-code-hash")?;
                 let multisig_script = MultisigScript::try_from(multisig_lock_code_hash.clone())
                     .map_err(|_err| {
                         format!(
@@ -651,7 +676,11 @@ fn print_cell_info(
     type_script_empty: bool,
 ) {
     let address_payload = AddressPayload::from(lock);
-    let lock_kind = if address_payload.code_hash(Some(network)) == MULTISIG_SCRIPT.code_hash.pack()
+    let lock_kind = if [
+        MultisigScript::Legacy.script_id().code_hash.pack(),
+        MultisigScript::V1.script_id().code_hash.pack(),
+    ]
+    .contains(&address_payload.code_hash(Some(network)))
     {
         if address_payload.args().len() == 20 {
             "multisig without since"
@@ -842,7 +871,7 @@ pub struct ReprMultisigConfig {
 
 // for compatibility
 fn compatibility_lock_code_hash() -> H256 {
-    MultisigScript::Deprecated.script_id().code_hash
+    MultisigScript::Legacy.script_id().code_hash
 }
 
 impl ReprMultisigConfig {

src/subcommands/tx.rs

@@ -14,7 +14,7 @@ use ckb_crypto::secp::SECP256K1;
 use ckb_hash::blake2b_256;
 use ckb_jsonrpc_types::{self as json_types, JsonBytes};
 use ckb_sdk::{
-    constants::{DAO_TYPE_HASH, MULTISIG_SCRIPT, SIGHASH_TYPE_HASH, TYPE_ID_CODE_HASH},
+    constants::{MultisigScript, DAO_TYPE_HASH, SIGHASH_TYPE_HASH, TYPE_ID_CODE_HASH},
     util::serialize_signature,
     Address, AddressPayload, NetworkType, OldAddress,
 };
@@ -111,6 +111,19 @@ impl<'a> UtilSubCommand<'a> {
             .conflicts_with(arg::privkey_path().get_name())
             .about("The address extended from `m/44'/309'/0'` (Search 2000 receiving addresses and 2000 change addresses max)");
 
+        let arg_multisig_lock_hash = Arg::with_name("multisig-code-hash")
+            .long("multisig-code-hash")
+            .takes_value(true)
+            .multiple(false)
+            .required(false)
+            .default_value("0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29")
+            .possible_values(&[
+                "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
+                "0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29",
+            ])
+            .validator(|input| FixedHashParser::<H256>::default().validate(input))
+            .about("Specifies the multisig code hash to use (default: `0x36c971b8d41fbd94aabca77dc75e826729ac98447b46f91e00796155dddb0d29`). \nThe alternative hash (`0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8`) is deprecated and NOT recommended for use.");
+
         App::new(name)
             .about("Utilities")
             .subcommands(vec![
@@ -263,6 +276,7 @@ impl<'a> UtilSubCommand<'a> {
                 App::new("to-multisig-addr")
                     .about("Convert address in single signature format to multisig format")
                     .arg(arg_sighash_address.clone())
+                .arg(arg_multisig_lock_hash.clone())
                     .arg(
                         Arg::with_name("locktime")
                             .long("locktime")
@@ -681,14 +695,24 @@ message = "0x"
                         .parse(input)?
                 };
 
+                let multisig_lock_code_hash: H256 =
+                    FixedHashParser::<H256>::default().from_matches(m, "multisig-code-hash")?;
+                let multisig_script = MultisigScript::try_from(multisig_lock_code_hash.clone())
+                    .map_err(|_err| {
+                        format!(
+                            "invalid multisig lock code hash: {}",
+                            multisig_lock_code_hash
+                        )
+                    })?;
+
                 let genesis_timestamp =
                     NaiveDateTime::parse_from_str("2019-11-16 06:00:00", "%Y-%m-%d  %H:%M:%S")
                         .map(|dt| dt.and_utc().timestamp_millis() as u64)
                         .unwrap();
                 let target_timestamp = to_timestamp(locktime)?;
                 let elapsed = target_timestamp.saturating_sub(genesis_timestamp);
                 let (epoch_fraction, addr_payload) =
-                    gen_multisig_addr(address.payload(), None, elapsed);
+                    gen_multisig_addr(multisig_script, address.payload(), None, elapsed);
                 let multisig_addr = Address::new(NetworkType::Mainnet, addr_payload, true);
                 let resp = format!("{},{},{}", address, locktime, multisig_addr);
                 if debug {
@@ -701,7 +725,7 @@ message = "0x"
                         elapsed / 1000,
                         epoch_fraction,
                         hex_string(multisig_addr.payload().args().as_ref()),
-                        MULTISIG_SCRIPT.code_hash,
+                        MultisigScript::Legacy.script_id().code_hash,
                     );
                 }
                 Ok(Output::new_output(serde_json::json!(resp)))
@@ -713,6 +737,16 @@ message = "0x"
                     DateTime::parse_from_rfc3339(m.value_of("locktime").unwrap())
                         .map(|dt| dt.timestamp_millis() as u64)
                         .map_err(|err| err.to_string())?;
+
+                let multisig_lock_code_hash: H256 =
+                    FixedHashParser::<H256>::default().from_matches(m, "multisig-code-hash")?;
+                let multisig_script = MultisigScript::try_from(multisig_lock_code_hash.clone())
+                    .map_err(|_err| {
+                        format!(
+                            "invalid multisig lock code hash: {}",
+                            multisig_lock_code_hash
+                        )
+                    })?;
                 let (tip_epoch, tip_timestamp) =
                     self.rpc_client.get_tip_header().map(|header_view| {
                         let header = header_view.inner;
@@ -722,7 +756,7 @@ message = "0x"
                     })?;
                 let elapsed = locktime_timestamp.saturating_sub(tip_timestamp.0);
                 let (epoch, multisig_addr) =
-                    gen_multisig_addr(address.payload(), Some(tip_epoch), elapsed);
+                    gen_multisig_addr(multisig_script, address.payload(), Some(tip_epoch), elapsed);
                 let resp = serde_json::json!({
                     "address": {
                         "mainnet": Address::new(NetworkType::Mainnet, multisig_addr.clone(), true).to_string(),
@@ -789,10 +823,10 @@ message = "0x"
                     },
                     "secp256k1_blake160_multisig_all": {
                         "script_id": {
-                            "code_hash": MULTISIG_SCRIPT.code_hash,
-                            "hash_type": json_types::ScriptHashType::from(MULTISIG_SCRIPT.hash_type),
+                            "code_hash": MultisigScript::Legacy.script_id().code_hash,
+                            "hash_type": json_types::ScriptHashType::from(MultisigScript::Legacy.script_id().hash_type),
                         },
-                        "cell_dep": json_types::CellDep::from(genesis_info.multisig_dep()),
+                        "cell_dep": json_types::CellDep::from(genesis_info.multisig_dep(MultisigScript::Legacy)),
                     },
                     "dao": {
                         "script_id": {
@@ -901,6 +935,7 @@ fn sign_message<P: ?Sized + AsRef<[ChildNumber]>>(
 }
 
 fn gen_multisig_addr(
+    multisig_script: MultisigScript,
     sighash_address_payload: &AddressPayload,
     tip_epoch_opt: Option<EpochNumberWithFraction>,
     elapsed: u64,
@@ -925,8 +960,8 @@ fn gen_multisig_addr(
         data.freeze()
     };
     let payload = AddressPayload::new_full(
-        MULTISIG_SCRIPT.hash_type,
-        MULTISIG_SCRIPT.code_hash.pack(),
+        multisig_script.script_id().hash_type,
+        multisig_script.script_id().code_hash.pack(),
         args,
     );
     (epoch_fraction, payload)
@@ -947,11 +982,13 @@ mod test {
     fn test_gen_multisig_addr() {
         let payload = AddressPayload::new_short(CodeHashIndex::Sighash, H160::default());
 
-        let (epoch, _) = gen_multisig_addr(&payload, None, BLOCK_PERIOD * 2000);
+        let (epoch, _) =
+            gen_multisig_addr(MultisigScript::Legacy, &payload, None, BLOCK_PERIOD * 2000);
         assert_eq!(epoch, EpochNumberWithFraction::new(1, 200, EPOCH_LENGTH));
 
         // (1+2/3) + (1+1/2) = 3+1/6
         let (epoch, _) = gen_multisig_addr(
+            MultisigScript::Legacy,
             &payload,
             Some(EpochNumberWithFraction::new(1, 400, 600)),
             BLOCK_PERIOD * 2700,

src/subcommands/util.rs

@@ -8,7 +8,7 @@ use ckb_chain_spec::consensus::TYPE_ID_CODE_HASH;
 use ckb_hash::new_blake2b;
 use ckb_jsonrpc_types as json_types;
 use ckb_sdk::{
-    constants::{MultisigScript, DAO_TYPE_HASH, MULTISIG_SCRIPT, SIGHASH_TYPE_HASH},
+    constants::{MultisigScript, DAO_TYPE_HASH, SIGHASH_TYPE_HASH},
     traits::{
         CellCollector, CellQueryOptions, DefaultCellCollector, DefaultHeaderDepResolver,
         DefaultTransactionDependencyProvider, MaturityOption, PrimaryScriptType, Signer,
@@ -169,9 +169,12 @@ impl<'a> WalletSubCommand<'a> {
             .transpose()?;
         let from_locked_address: Option<Address> = from_locked_address
             .map(|input| {
-                AddressParser::new_multisig()
+                AddressParser::new_multisig(MultisigScript::Legacy)
                     .set_network(network_type)
                     .parse(&input)
+                    .or(AddressParser::new_multisig(MultisigScript::V1)
+                        .set_network(network_type)
+                        .parse(&input))
             })
             .transpose()?;
         let to_capacity: u64 = CapacityParser.parse(&capacity)?.into();
@@ -243,11 +246,11 @@ impl<'a> WalletSubCommand<'a> {
             || (to_address_hash_type == ScriptHashType::Type
                 && to_address_code_hash == SIGHASH_TYPE_HASH
                 && to_address_args_len == 20)
-            || (to_address_hash_type == MultisigScript::Latest.script_id().hash_type
-                && to_address_code_hash == MultisigScript::Latest.script_id().code_hash
+            || (to_address_hash_type == MultisigScript::V1.script_id().hash_type
+                && to_address_code_hash == MultisigScript::V1.script_id().code_hash
                 && (to_address_args_len == 20 || to_address_args_len == 28))
-            || (to_address_hash_type == MultisigScript::Deprecated.script_id().hash_type
-                && to_address_code_hash == MultisigScript::Deprecated.script_id().code_hash
+            || (to_address_hash_type == MultisigScript::Legacy.script_id().hash_type
+                && to_address_code_hash == MultisigScript::Legacy.script_id().code_hash
                 && (to_address_args_len == 20 || to_address_args_len == 28)))
         {
             return Err(format!(
@@ -355,7 +358,7 @@ impl<'a> WalletSubCommand<'a> {
                 let threshold = 1;
 
                 let mut matched_multisig_config = None;
-                for multisig_script in [MultisigScript::Latest, MultisigScript::Deprecated] {
+                for multisig_script in [MultisigScript::V1, MultisigScript::Legacy] {
                     let config = MultisigConfig::new_with(
                         multisig_script,
                         sighash_addresses.clone(),
@@ -377,7 +380,15 @@ impl<'a> WalletSubCommand<'a> {
                         0,
                         (lock_script, placehodler_witness, SinceSource::LockArgs(20)),
                     );
-                    let multisig_script_id = MULTISIG_SCRIPT;
+                    let multisig_script_id =
+                        MultisigScript::try_from(matched_multisig_config.lock_code_hash())
+                            .unwrap_or_else(|_| {
+                                panic!(
+                                    "must get multisig script by {}",
+                                    matched_multisig_config.lock_code_hash()
+                                )
+                            })
+                            .script_id();
                     let multisig_unlocker = {
                         let signer = get_signer()?;
                         SecpMultisigUnlocker::new(SecpMultisigScriptSigner::new(