diff --git a/examples/dao_deposit_example.rs b/examples/dao_deposit_example.rs
new file mode 100644
index 00000000..4f4c9e8a
--- /dev/null
+++ b/examples/dao_deposit_example.rs
@@ -0,0 +1,52 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{dao, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::h256;
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r")?;
+    let receiver=Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new(vec![(&sender).into()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    let context = dao::DepositContext::new((&receiver).into(), 510_0000_0000u64);
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    builder.set_change_lock((&sender).into());
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_keys = vec![h256!(
+        "0x6c9ed03816e3111e49384b8d180174ad08e29feb1393ea1b51cef1c505d4e36a"
+    )];
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_sighash_h256(private_keys)?,
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: 8b7ab7770c821fa8dc70738d5d6ef43da46706541c258b9a02edf66948039798
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/dao_withdraw_phrase1_example.rs b/examples/dao_withdraw_phrase1_example.rs
new file mode 100644
index 00000000..5698c1d5
--- /dev/null
+++ b/examples/dao_withdraw_phrase1_example.rs
@@ -0,0 +1,61 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{dao, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::h256;
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new(vec![(&sender).into()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    let mut context = dao::WithdrawPhrase1Context::new(network_info.url.clone());
+    let input_outpoint = serde_json::from_str::<ckb_jsonrpc_types::OutPoint>(
+        r#"
+   {
+      "tx_hash": "0x2aba579894cdf5f6c4afd3ada52792c4405fe6ba64d05226fb63fa5c1ec6f666",
+      "index": "0x0"
+   }
+   "#,
+    )
+    .unwrap();
+    context.add_input_outpoint(input_outpoint.into(), None);
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    builder.set_change_lock((&sender).into());
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_keys = vec![h256!(
+        "0x6c9ed03816e3111e49384b8d180174ad08e29feb1393ea1b51cef1c505d4e36a"
+    )];
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_sighash_h256(private_keys)?,
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: b615b9cbb566af18dd2d860836b89e07a86dfcc7af510595dcb404f1b19e6d7e
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/dao_withdraw_phrase2_example.rs b/examples/dao_withdraw_phrase2_example.rs
new file mode 100644
index 00000000..e29239b7
--- /dev/null
+++ b/examples/dao_withdraw_phrase2_example.rs
@@ -0,0 +1,61 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{dao, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::h256;
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new(vec![(&sender).into()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    let input_outpoint = serde_json::from_str::<ckb_jsonrpc_types::OutPoint>(
+        r#"
+   {
+      "tx_hash": "0x770f930ed3bf35664cb6a112edce3287712f0613c74c1f1176e099ee51268489",
+      "index": "0x0"
+   }
+   "#,
+    )
+    .unwrap();
+    let context =
+        dao::WithdrawPhrase2Context::new(vec![input_outpoint.into()], network_info.url.clone());
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    builder.set_change_lock((&sender).into());
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_keys = vec![h256!(
+        "0x6c9ed03816e3111e49384b8d180174ad08e29feb1393ea1b51cef1c505d4e36a"
+    )];
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_sighash_h256(private_keys)?,
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: 0xaae93c573848a632f06f01c7c444c90aa490253f35b4212d147882266960a267
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/omnilock_example.rs b/examples/omnilock_example.rs
new file mode 100644
index 00000000..a35b9ee2
--- /dev/null
+++ b/examples/omnilock_example.rs
@@ -0,0 +1,58 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{omnilock, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    unlock::OmniLockConfig,
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::{core::Capacity, h256};
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qrejnmlar3r452tcg57gvq8patctcgy8acync0hxfnyka35ywafvkqgqgpy7m88v3gxnn3apazvlpkkt32xz3tg5qq3kzjf3")?;
+    let receiver = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new_with_address(&[sender.clone()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    builder.add_output_from_addr(&receiver, Capacity::bytes(128)?);
+    builder.set_change_addr(&sender);
+
+    let omni_cfg = OmniLockConfig::from_addr(&sender).unwrap();
+    let context = omnilock::OmnilockScriptContext::new(omni_cfg.clone(), network_info.url.clone());
+
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_key = h256!("0x6c9ed03816e3111e49384b8d180174ad08e29feb1393ea1b51cef1c505d4e36a");
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_omnilock(
+            secp256k1::SecretKey::from_slice(private_key.as_bytes())?,
+            omni_cfg,
+        ),
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: 0xc0c9954a3299b540e63351146a301438372abf93682d96c7cce691c334dd5757
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/omnilock_multisig_example.rs b/examples/omnilock_multisig_example.rs
new file mode 100644
index 00000000..7a48b29a
--- /dev/null
+++ b/examples/omnilock_multisig_example.rs
@@ -0,0 +1,77 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{omnilock, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    unlock::{MultisigConfig, OmniLockConfig},
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::{core::Capacity, h160, h256};
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qrejnmlar3r452tcg57gvq8patctcgy8acync0hxfnyka35ywafvkqgxhjvp3k9pf88upngryvuxc346q7fq5qmlqqlrhr0p")?;
+    let receiver = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new_with_address(&[sender.clone()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    builder.add_output_from_addr(&receiver, Capacity::bytes(128)?);
+    builder.set_change_addr(&sender);
+
+    let mut omni_cfg = OmniLockConfig::from_addr(&sender).unwrap();
+    let multisig_config = MultisigConfig::new_with(
+        vec![
+            h160!("0x7336b0ba900684cb3cb00f0d46d4f64c0994a562"),
+            h160!("0x5724c1e3925a5206944d753a6f3edaedf977d77f"),
+        ],
+        0,
+        2,
+    )
+    .unwrap();
+    omni_cfg.set_multisig_config(Some(multisig_config));
+    let context = omnilock::OmnilockScriptContext::new(omni_cfg.clone(), network_info.url.clone());
+
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let signer = TransactionSigner::new(&network_info);
+    let private_key = h256!("0x7438f7b35c355e3d2fb9305167a31a72d22ddeafb80a21cc99ff6329d92e8087");
+    signer.sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_omnilock(
+            secp256k1::SecretKey::from_slice(private_key.as_bytes())?,
+            omni_cfg.clone(),
+        ),
+    )?;
+    let private_key = h256!("0x4fd809631a6aa6e3bb378dd65eae5d71df895a82c91a615a1e8264741515c79c");
+    signer.sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_omnilock(
+            secp256k1::SecretKey::from_slice(private_key.as_bytes())?,
+            omni_cfg,
+        ),
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: 3c5062f75f8c9dc799a3286ebef070cd3aa1b51575244c912076b90cb915a374
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/send_ckb_example.rs b/examples/send_ckb_example.rs
index 35a88806..93dd85bc 100644
--- a/examples/send_ckb_example.rs
+++ b/examples/send_ckb_example.rs
@@ -28,7 +28,7 @@ fn main() -> Result<(), Box<dyn StdErr>> {
     let addr = Address::from_str(sender)?;
     builder.add_output_from_addr(&receiver, Capacity::shannons(510_0000_0000u64));
     builder.set_change_addr(&addr);
-    let mut tx_with_groups = builder.build(&Default::default())?;
+    let mut tx_with_groups = builder.build(&mut Default::default())?;
 
     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());
diff --git a/examples/send_ckb_multisig_example.rs b/examples/send_ckb_multisig_example.rs
index 5b45aa94..91e42ebe 100644
--- a/examples/send_ckb_multisig_example.rs
+++ b/examples/send_ckb_multisig_example.rs
@@ -40,7 +40,7 @@ fn main() -> Result<(), Box<dyn StdErr>> {
     builder.add_output_from_addr(&addr, Capacity::shannons(501_0000_0000u64));
     builder.set_change_addr(&sender_addr);
     let mut tx_with_groups =
-        builder.build(&HandlerContexts::new_multisig(multisig_config.clone()))?;
+        builder.build(&mut HandlerContexts::new_multisig(multisig_config.clone()))?;
 
     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());
diff --git a/examples/sudt_issue_example.rs b/examples/sudt_issue_example.rs
new file mode 100644
index 00000000..c70fbee2
--- /dev/null
+++ b/examples/sudt_issue_example.rs
@@ -0,0 +1,57 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{udt, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::h256;
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let owner = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdamwzrffgc54ef48493nfd2sd0h4cjnxg4850up")?;
+    let receiver=Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new(vec![(&owner).into()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    let context = udt::UdtIssueContext::new_default(
+        (&owner).into(),
+        (&receiver).into(),
+        10u128,
+        &network_info,
+    );
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    builder.set_change_lock((&owner).into());
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_keys = vec![h256!(
+        "0x0c982052ffd4af5f3bbf232301dcddf468009161fc48ba1426e3ce0929fb59f8"
+    )];
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_sighash_h256(private_keys)?,
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: e992819c59233c05eb83552203695840b5e76a2c3faf606adee4a1d1df4837d9
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/examples/sudt_transfer_example.rs b/examples/sudt_transfer_example.rs
new file mode 100644
index 00000000..4a205c64
--- /dev/null
+++ b/examples/sudt_transfer_example.rs
@@ -0,0 +1,61 @@
+use ckb_sdk::{
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        handler::{udt, HandlerContexts},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    Address, CkbRpcClient, NetworkInfo,
+};
+use ckb_types::h256;
+use std::{error::Error as StdErr, str::FromStr};
+
+fn main() -> Result<(), Box<dyn StdErr>> {
+    let network_info = NetworkInfo::testnet();
+    let sender = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdamwzrffgc54ef48493nfd2sd0h4cjnxg4850up")?;
+    let receiver=Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqd0pdquvfuq077aemn447shf4d8u5f4a0glzz2g4")?;
+
+    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;
+
+    let iterator = InputIterator::new(vec![(&sender).into()], configuration.network_info());
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+
+    let context = udt::UdtTransferContext::from_owner(
+        &(&sender).into(),
+        (&sender).into(),
+        (&receiver).into(),
+        1u128,
+        &network_info,
+    );
+    // context.set_keep_zero_udt_cell(false);
+    // let udt_change_address = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;
+    // context.set_udt_change_lock(Some((&udt_change_address).into()));
+    let mut contexts = HandlerContexts::default();
+    contexts.add_context(Box::new(context) as Box<_>);
+
+    builder.set_change_lock((&sender).into());
+    let mut tx_with_groups = builder.build(&mut contexts)?;
+
+    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());
+
+    let private_keys = vec![h256!(
+        "0x0c982052ffd4af5f3bbf232301dcddf468009161fc48ba1426e3ce0929fb59f8"
+    )];
+    TransactionSigner::new(&network_info).sign_transaction(
+        &mut tx_with_groups,
+        &SignContexts::new_sighash_h256(private_keys)?,
+    )?;
+
+    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());
+
+    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
+        .send_transaction(json_tx.inner, None)
+        .expect("send transaction");
+    // example tx: d231a37f1f8787b98b6021783240205cf7185a45be4f304d6e8f2437f252f704
+    println!(">>> tx {} sent! <<<", tx_hash);
+
+    Ok(())
+}
diff --git a/src/core/advanced_builders.rs b/src/core/advanced_builders.rs
index 8a39d59e..af0af9e4 100644
--- a/src/core/advanced_builders.rs
+++ b/src/core/advanced_builders.rs
@@ -1,4 +1,8 @@
-use ckb_types::{constants, core, packed, prelude::*};
+use ckb_types::{
+    constants, core,
+    packed::{self, WitnessArgs},
+    prelude::*,
+};
 use derive_getters::Getters;
 
 /// An advanced builder for [`TransactionView`].
@@ -122,7 +126,7 @@ macro_rules! def_setter_for_vector {
         def_setter_for_vector!(packed, $field, $type, $func_push, $func_extend, $func_set);
     };
     (set_i, $field:ident, $type:ident, $func_push:ident, $func_extend:ident, $func_set:ident, $func_set_i: ident) => {
-        def_setter_for_vector!(packed, $field, $type, $func_push, $func_extend, $func_set);
+        def_setter_for_vector!($field, $type, $func_push, $func_extend, $func_set);
 
         pub fn $func_set_i(&mut self, i: usize, v: packed::$type) -> &mut Self {
             self.$field[i] = v;
@@ -138,11 +142,12 @@ macro_rules! def_dedup_setter_for_vector {
         $comment_push:expr, $comment_extend:expr,
     ) => {
         #[doc = $comment_push]
-        pub fn $func_push(&mut self, v: $prefix::$type) -> &mut Self {
-            if !self.$field.contains(&v) {
-                self.$field.push(v);
+        pub fn $func_push(&mut self, v: $prefix::$type) -> usize {
+            if let Some(idx) = self.$field.iter().position(|x| x == &v) {
+                return idx;
             }
-            self
+            self.$field.push(v);
+            self.$field.len() - 1
         }
         #[doc = $comment_extend]
         pub fn $func_extend<T>(&mut self, v: T) -> &mut Self
@@ -221,6 +226,46 @@ impl TransactionBuilder {
         set_outputs_data
     );
 
+    fn get_witness_obj(&self, i: usize) -> WitnessArgs {
+        let witness_data = self.witnesses[i].raw_data();
+        if witness_data.is_empty() {
+            WitnessArgs::default()
+        } else {
+            WitnessArgs::from_slice(witness_data.as_ref()).unwrap()
+        }
+    }
+    pub fn set_witness_lock(&mut self, i: usize, v: Option<bytes::Bytes>) -> &mut Self {
+        let current_witness = self.get_witness_obj(i);
+        self.witnesses[i] = current_witness
+            .as_builder()
+            .lock(v.pack())
+            .build()
+            .as_bytes()
+            .pack();
+        self
+    }
+
+    pub fn set_witness_input(&mut self, i: usize, v: Option<bytes::Bytes>) -> &mut Self {
+        self.witnesses[i] = self
+            .get_witness_obj(i)
+            .as_builder()
+            .input_type(v.pack())
+            .build()
+            .as_bytes()
+            .pack();
+        self
+    }
+
+    pub fn set_witness_output(&mut self, i: usize, v: Option<bytes::Bytes>) -> &mut Self {
+        self.witnesses[i] = self
+            .get_witness_obj(i)
+            .as_builder()
+            .output_type(v.pack())
+            .build()
+            .as_bytes()
+            .pack();
+        self
+    }
     /// Converts into [`TransactionView`](struct.TransactionView.html).
     pub fn build(self) -> core::TransactionView {
         let Self {
@@ -247,4 +292,13 @@ impl TransactionBuilder {
 
         tx.into_view()
     }
+
+    pub(crate) fn set_input_since(&mut self, i: usize, since: u64) -> &mut Self {
+        self.inputs[i] = self.inputs[i]
+            .clone()
+            .as_builder()
+            .since(since.pack())
+            .build();
+        self
+    }
 }
diff --git a/src/tests/transaction/mod.rs b/src/tests/transaction/mod.rs
index 3050d6d3..ac42796e 100644
--- a/src/tests/transaction/mod.rs
+++ b/src/tests/transaction/mod.rs
@@ -1 +1,2 @@
 pub mod sighash;
+pub mod typeid;
diff --git a/src/tests/transaction/sighash.rs b/src/tests/transaction/sighash.rs
index 162366d5..fcd012aa 100644
--- a/src/tests/transaction/sighash.rs
+++ b/src/tests/transaction/sighash.rs
@@ -43,7 +43,9 @@ fn test_transfer_from_sighash() {
     let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
     builder.add_output(output.clone(), ckb_types::packed::Bytes::default());
     builder.set_change_lock(sender.clone());
-    let mut tx_with_groups = builder.build(&Default::default()).expect("build failed");
+    let mut tx_with_groups = builder
+        .build(&mut Default::default())
+        .expect("build failed");
 
     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());
@@ -106,7 +108,9 @@ fn test_transfer_from_sighash_samll_to_fee() {
     let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
     builder.add_output(output.clone(), ckb_types::packed::Bytes::default());
     builder.set_change_lock(sender.clone());
-    let mut tx_with_groups = builder.build(&Default::default()).expect("build failed");
+    let mut tx_with_groups = builder
+        .build(&mut Default::default())
+        .expect("build failed");
 
     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());
@@ -167,7 +171,9 @@ fn test_transfer_from_sighash_samll_to_receiver() {
     let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
     builder.add_output(output, ckb_types::packed::Bytes::default());
     builder.set_change_lock(sender.clone());
-    let mut tx_with_groups = builder.build(&Default::default()).expect("build failed");
+    let mut tx_with_groups = builder
+        .build(&mut Default::default())
+        .expect("build failed");
 
     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());
diff --git a/src/tests/transaction/typeid.rs b/src/tests/transaction/typeid.rs
new file mode 100644
index 00000000..f2f03df5
--- /dev/null
+++ b/src/tests/transaction/typeid.rs
@@ -0,0 +1,69 @@
+use ckb_types::{packed::CellOutput, prelude::*};
+
+use crate::{
+    constants::{self, ONE_CKB},
+    tests::{build_sighash_script, init_context, ACCOUNT1_ARG, ACCOUNT1_KEY, FEE_RATE},
+    transaction::{
+        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
+        input::InputIterator,
+        signer::{SignContexts, TransactionSigner},
+        TransactionBuilderConfiguration,
+    },
+    NetworkInfo, ScriptId,
+};
+
+#[test]
+fn test_deploy_id() {
+    let sender = build_sighash_script(ACCOUNT1_ARG);
+    let ctx = init_context(Vec::new(), vec![(sender.clone(), Some(10_0000 * ONE_CKB))]);
+
+    let network_info = NetworkInfo::testnet();
+    let type_script = ScriptId::new_type(constants::TYPE_ID_CODE_HASH.clone()).dummy_script();
+
+    let output = CellOutput::new_builder()
+        .capacity((120 * ONE_CKB).pack())
+        .lock(sender.clone())
+        .type_(Some(type_script).pack())
+        .build();
+    let configuration =
+        TransactionBuilderConfiguration::new_with_network(network_info.clone()).unwrap();
+
+    let iterator = InputIterator::new_with_cell_collector(
+        vec![sender.clone()],
+        Box::new(ctx.to_live_cells_context()) as Box<_>,
+    );
+    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);
+    builder.add_output(output, bytes::Bytes::from(vec![0x01u8; 64]).pack());
+    builder.set_change_lock(sender.clone());
+    let mut tx_with_groups = builder
+        .build(&mut Default::default())
+        .expect("build failed");
+
+    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());
+
+    TransactionSigner::new(&network_info)
+        .sign_transaction(
+            &mut tx_with_groups,
+            &SignContexts::new_sighash_h256(vec![ACCOUNT1_KEY.clone()]).unwrap(),
+        )
+        .unwrap();
+
+    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());
+
+    let tx = tx_with_groups.get_tx_view().clone();
+    let script_groups = tx_with_groups.script_groups.clone();
+    assert_eq!(script_groups.len(), 2);
+    assert_eq!(tx.header_deps().len(), 0);
+    assert_eq!(tx.cell_deps().len(), 1);
+    assert_eq!(tx.inputs().len(), 1);
+    for out_point in tx.input_pts_iter() {
+        assert_eq!(ctx.get_input(&out_point).unwrap().0.lock(), sender);
+    }
+    assert_eq!(tx.outputs().len(), 2);
+    // assert_eq!(tx.output(0).unwrap(), output);
+    assert_eq!(tx.output(1).unwrap().lock(), sender);
+
+    ctx.verify(tx, FEE_RATE).unwrap();
+}
diff --git a/src/transaction/builder/mod.rs b/src/transaction/builder/mod.rs
index fd98b3de..82de9755 100644
--- a/src/transaction/builder/mod.rs
+++ b/src/transaction/builder/mod.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, vec};
 
 use super::{
     handler::HandlerContexts,
@@ -22,7 +22,7 @@ pub use fee_calculator::FeeCalculator;
 pub trait CkbTransactionBuilder {
     fn build(
         &mut self,
-        contexts: &HandlerContexts,
+        contexts: &mut HandlerContexts,
     ) -> Result<TransactionWithScriptGroups, TxBuilderError>;
 }
 
@@ -36,6 +36,12 @@ pub struct SimpleTransactionBuilder {
     reward: u64,
 }
 
+pub struct PrepareTransactionViewer<'a> {
+    pub(crate) transaction_inputs: &'a mut Vec<TransactionInput>,
+    pub(crate) tx: &'a mut TransactionBuilder,
+    pub(crate) reward: &'a mut u64,
+}
+
 impl SimpleTransactionBuilder {
     pub fn new(configuration: TransactionBuilderConfiguration, input_iter: InputIterator) -> Self {
         Self {
@@ -132,8 +138,68 @@ impl SimpleTransactionBuilder {
             .capacity((capacity + delta_capacity).pack())
             .build();
         tx_builder.set_output(idx, output);
+
+        Ok(())
+    }
+
+    fn prepare_transaction(
+        viewer: &mut PrepareTransactionViewer,
+        configuration: &TransactionBuilderConfiguration,
+        contexts: &mut HandlerContexts,
+    ) -> Result<(), TxBuilderError> {
+        for handler in configuration.get_script_handlers() {
+            for context in &mut contexts.contexts {
+                if handler.prepare_transaction(viewer, context.as_mut())? {
+                    break;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn post_build(
+        type_groups: &HashMap<Byte32, ScriptGroup>,
+        configuration: &TransactionBuilderConfiguration,
+        tx_builder: &mut TransactionBuilder,
+        contexts: &mut HandlerContexts,
+    ) -> Result<(), TxBuilderError> {
+        for idx in type_groups
+            .values()
+            .flat_map(|group| group.output_indices.iter())
+        {
+            for handler in configuration.get_script_handlers() {
+                for context in &mut contexts.contexts {
+                    if handler.post_build(*idx, tx_builder, context.as_mut())? {
+                        break;
+                    }
+                }
+            }
+        }
         Ok(())
     }
+    fn rebuild_type_script_group(
+        tx_builder: &TransactionBuilder,
+        type_groups: HashMap<Byte32, ScriptGroup>,
+    ) -> HashMap<Byte32, ScriptGroup> {
+        let mut ret = HashMap::default();
+        for (key, old_group) in type_groups.into_iter() {
+            if !old_group.input_indices.is_empty() {
+                let new_group = ret
+                    .entry(key)
+                    .or_insert_with(|| ScriptGroup::from_type_script(&old_group.script));
+                new_group.input_indices.extend(old_group.input_indices);
+            }
+            for idx in old_group.output_indices {
+                let output = tx_builder.get_outputs().get(idx).unwrap();
+                let type_ = output.type_().to_opt().unwrap();
+                let new_group = ret
+                    .entry(type_.calc_script_hash())
+                    .or_insert_with(|| ScriptGroup::from_type_script(&type_));
+                new_group.output_indices.push(idx);
+            }
+        }
+        ret
+    }
 }
 
 macro_rules! celloutput_capacity {
@@ -143,11 +209,22 @@ macro_rules! celloutput_capacity {
     }};
 }
 
+macro_rules! prepare_veiwer {
+    ($self:ident) => {
+        PrepareTransactionViewer {
+            transaction_inputs: &mut $self.transaction_inputs,
+            tx: &mut $self.tx,
+            reward: &mut $self.reward,
+        }
+    };
+}
+
 impl CkbTransactionBuilder for SimpleTransactionBuilder {
     fn build(
         &mut self,
-        contexts: &HandlerContexts,
+        contexts: &mut HandlerContexts,
     ) -> Result<TransactionWithScriptGroups, TxBuilderError> {
+        Self::prepare_transaction(&mut prepare_veiwer!(self), &self.configuration, contexts)?;
         let mut lock_groups: HashMap<Byte32, ScriptGroup> = HashMap::default();
         let mut type_groups: HashMap<Byte32, ScriptGroup> = HashMap::default();
         let mut outputs_capacity = 0u64;
@@ -171,9 +248,9 @@ impl CkbTransactionBuilder for SimpleTransactionBuilder {
             InputView::new(&self.transaction_inputs, &mut self.input_iter).enumerate()
         {
             let input = input?;
-            self.tx.input(input.cell_input());
+            self.tx.input(input.cell_input(0));
             let previous_output = input.previous_output();
-            self.tx.witness(packed::Bytes::default());
+            self.tx.witness(Default::default());
             let lock_script = previous_output.lock();
             let script_group = lock_groups
                 .entry(lock_script.calc_script_hash())
@@ -269,7 +346,9 @@ impl CkbTransactionBuilder for SimpleTransactionBuilder {
         if !state.is_success() {
             return Err(TxBuilderError::BalanceCapacity(state.into()));
         }
-        let script_groups = lock_groups
+        Self::post_build(&type_groups, &self.configuration, &mut self.tx, contexts)?;
+        let type_groups = Self::rebuild_type_script_group(&self.tx, type_groups);
+        let script_groups: Vec<ScriptGroup> = lock_groups
             .into_values()
             .chain(type_groups.into_values())
             .collect();
diff --git a/src/transaction/handler/dao.rs b/src/transaction/handler/dao.rs
new file mode 100644
index 00000000..edcbf766
--- /dev/null
+++ b/src/transaction/handler/dao.rs
@@ -0,0 +1,373 @@
+use std::collections::HashMap;
+
+use anyhow::anyhow;
+use ckb_types::{
+    core::{Capacity, DepType, ScriptHashType},
+    h256,
+    packed::{CellDep, CellInput, CellOutput, OutPoint, Script},
+    prelude::{Builder, Entity, Pack, Unpack},
+};
+use lazy_static::lazy_static;
+
+use crate::{
+    constants,
+    traits::{
+        DefaultHeaderDepResolver, DefaultTransactionDependencyProvider, HeaderDepResolver,
+        TransactionDependencyProvider,
+    },
+    transaction::{builder::PrepareTransactionViewer, input::TransactionInput},
+    tx_builder::{
+        dao::{DaoDepositReceiver, DaoPrepareItem},
+        TxBuilderError,
+    },
+    util::{calculate_dao_maximum_withdraw4, minimal_unlock_point},
+    NetworkInfo, NetworkType, ScriptGroup, Since, SinceType,
+};
+
+use super::{HandlerContext, ScriptHandler};
+
+pub const DAO_DATA_LEN: usize = 8;
+lazy_static! {
+    static ref DAO_TYPE_SCRIPT: Script = Script::new_builder()
+        .code_hash(constants::DAO_TYPE_HASH.pack())
+        .hash_type(ScriptHashType::Type.into())
+        .build();
+    static ref DEPOSIT_CELL_DATA: ckb_types::packed::Bytes =
+        bytes::Bytes::from(vec![0u8; DAO_DATA_LEN]).pack();
+}
+
+pub struct DaoScriptHandler {
+    cell_deps: Vec<CellDep>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct DepositContext {
+    // lock script, capacity list
+    pub receivers: Vec<DaoDepositReceiver>,
+}
+
+impl DepositContext {
+    pub fn new(lock_script: Script, capacity: u64) -> Self {
+        let mut ret = Self::default();
+        ret.add_output(lock_script, capacity);
+        ret
+    }
+
+    pub fn add_output(&mut self, lock_script: Script, capacity: u64) {
+        self.receivers
+            .push(DaoDepositReceiver::new(lock_script, capacity));
+    }
+}
+
+impl HandlerContext for DepositContext {}
+
+#[derive(Default)]
+pub struct WithdrawPhrase1Context {
+    pub items: Vec<DaoPrepareItem>,
+    pub rpc_url: String,
+}
+
+impl WithdrawPhrase1Context {
+    /// add input.
+    /// If `receiver_lock` is `None` copy the lock script from input with same
+    /// index, otherwise replace the lock script with the given script.
+    pub fn add_input(&mut self, input: CellInput, receiver_lock: Option<Script>) {
+        self.items.push(DaoPrepareItem {
+            input,
+            lock_script: receiver_lock,
+        });
+    }
+
+    pub fn add_input_outpoint(&mut self, input_outpoint: OutPoint, receiver_lock: Option<Script>) {
+        self.items.push(DaoPrepareItem {
+            input: CellInput::new_builder()
+                .previous_output(input_outpoint)
+                .build(),
+            lock_script: receiver_lock,
+        });
+    }
+
+    pub fn new(rpc_url: String) -> Self {
+        Self {
+            rpc_url,
+            ..Default::default()
+        }
+    }
+}
+
+impl HandlerContext for WithdrawPhrase1Context {}
+
+pub struct WithdrawPhrase2Context {
+    /// Withdraw from those out_points (prepared cells)
+    items: Vec<OutPoint>,
+    rpc_url: String,
+    // input_index => (deposit_header_index, since_value)
+    deposit_header_indexes: HashMap<usize, (usize, u64)>,
+}
+
+impl WithdrawPhrase2Context {
+    pub fn new(items: Vec<OutPoint>, rpc_url: String) -> Self {
+        Self {
+            items,
+            rpc_url,
+            deposit_header_indexes: HashMap::new(),
+        }
+    }
+}
+
+impl HandlerContext for WithdrawPhrase2Context {}
+
+impl DaoScriptHandler {
+    pub fn is_match(&self, script: &Script) -> bool {
+        script.code_hash() == constants::DAO_TYPE_HASH.pack()
+    }
+    pub fn new_with_network(network: &NetworkInfo) -> Result<Self, TxBuilderError> {
+        let mut ret = Self { cell_deps: vec![] };
+        ret.init(network)?;
+        Ok(ret)
+    }
+
+    pub fn build_phrase1_base(
+        viewer: &mut PrepareTransactionViewer,
+        context: &WithdrawPhrase1Context,
+    ) -> Result<(), TxBuilderError> {
+        if context.items.is_empty() {
+            return Err(TxBuilderError::InvalidParameter(anyhow!(
+                "No cell to prepare"
+            )));
+        }
+
+        let header_dep_resolver = DefaultHeaderDepResolver::new(&context.rpc_url);
+        let tx_dep_provider = DefaultTransactionDependencyProvider::new(&context.rpc_url, 10);
+
+        for DaoPrepareItem { input, lock_script } in &context.items {
+            let out_point = input.previous_output();
+            let tx_hash = out_point.tx_hash();
+            let deposit_header = header_dep_resolver
+                .resolve_by_tx(&tx_hash)
+                .map_err(TxBuilderError::Other)?
+                .ok_or_else(|| TxBuilderError::ResolveHeaderDepByTxHashFailed(tx_hash.clone()))?;
+            let (input_cell, data) = tx_dep_provider.get_cell_with_data(&out_point)?;
+            if input_cell.type_().to_opt().as_ref() != Some(&DAO_TYPE_SCRIPT) {
+                return Err(TxBuilderError::InvalidParameter(anyhow!(
+                    "the input cell has invalid type script"
+                )));
+            }
+
+            let output = {
+                let mut builder = input_cell.clone().as_builder();
+                if let Some(script) = lock_script {
+                    builder = builder.lock(script.clone());
+                }
+                builder.build()
+            };
+            let output_data = bytes::Bytes::from(deposit_header.number().to_le_bytes().to_vec());
+
+            let transaction_input = TransactionInput::new(input_cell, data, out_point);
+            viewer.transaction_inputs.push(transaction_input);
+
+            viewer.tx.dedup_header_dep(deposit_header.hash());
+
+            viewer.tx.output(output);
+            viewer.tx.output_data(output_data.pack());
+        }
+        Ok(())
+    }
+
+    pub fn build_phrase2_base(
+        viewer: &mut PrepareTransactionViewer,
+        context: &mut WithdrawPhrase2Context,
+    ) -> Result<(), TxBuilderError> {
+        if context.items.is_empty() {
+            return Err(TxBuilderError::InvalidParameter(anyhow!(
+                "No cell to withdraw"
+            )));
+        }
+
+        let header_dep_resolver = DefaultHeaderDepResolver::new(&context.rpc_url);
+        let tx_dep_provider = DefaultTransactionDependencyProvider::new(&context.rpc_url, 10);
+
+        let mut prepare_block_hashes = Vec::new();
+        for out_point in &context.items {
+            let tx_hash = out_point.tx_hash();
+            let prepare_header = header_dep_resolver
+                .resolve_by_tx(&tx_hash)
+                .map_err(TxBuilderError::Other)?
+                .ok_or_else(|| TxBuilderError::ResolveHeaderDepByTxHashFailed(tx_hash.clone()))?;
+            prepare_block_hashes.push(prepare_header.hash());
+            let input_cell = tx_dep_provider.get_cell(out_point)?;
+            if input_cell.type_().to_opt().as_ref() != Some(&DAO_TYPE_SCRIPT) {
+                return Err(TxBuilderError::InvalidParameter(anyhow!(
+                    "the input cell has invalid type script"
+                )));
+            }
+
+            let data = tx_dep_provider.get_cell_data(out_point)?;
+            if data.len() != DAO_DATA_LEN {
+                return Err(TxBuilderError::InvalidParameter(anyhow!(
+                    "the input cell has invalid data length, expected: 8, got: {}",
+                    data.len()
+                )));
+            }
+
+            let deposit_header = {
+                let deposit_number = {
+                    let mut number_bytes = [0u8; DAO_DATA_LEN];
+                    number_bytes.copy_from_slice(data.as_ref());
+                    u64::from_le_bytes(number_bytes)
+                };
+                header_dep_resolver
+                    .resolve_by_number(deposit_number)
+                    .or_else(|_err| {
+                        // for light client
+                        let prepare_tx = tx_dep_provider.get_transaction(&tx_hash)?;
+                        for input in prepare_tx.inputs() {
+                            let _ = header_dep_resolver
+                                .resolve_by_tx(&input.previous_output().tx_hash())?;
+                        }
+                        header_dep_resolver.resolve_by_number(deposit_number)
+                    })
+                    .map_err(TxBuilderError::Other)?
+                    .ok_or(TxBuilderError::ResolveHeaderDepByNumberFailed(
+                        deposit_number,
+                    ))?
+            };
+
+            // calculate reward
+            {
+                let occupied_capacity = input_cell
+                    .occupied_capacity(Capacity::bytes(data.len()).unwrap())
+                    .unwrap();
+                let input_capacity = calculate_dao_maximum_withdraw4(
+                    &deposit_header,
+                    &prepare_header,
+                    &input_cell,
+                    occupied_capacity.as_u64(),
+                );
+                let tmp_capacity: u64 = input_cell.capacity().unpack();
+                *viewer.reward += input_capacity - tmp_capacity;
+            }
+            // build live cell
+            {
+                let transaction_input = TransactionInput::new(input_cell, data, out_point.clone());
+                viewer.transaction_inputs.push(transaction_input);
+            };
+            let unlock_point = minimal_unlock_point(&deposit_header, &prepare_header);
+            let since = Since::new(
+                SinceType::EpochNumberWithFraction,
+                unlock_point.full_value(),
+                false,
+            );
+            let deposit_block_hash = deposit_header.hash();
+            let dep_header_idx = viewer.tx.dedup_header_dep(deposit_block_hash);
+            context.deposit_header_indexes.insert(
+                viewer.transaction_inputs.len() - 1,
+                (dep_header_idx, since.value()),
+            );
+        }
+        viewer.tx.dedup_header_deps(prepare_block_hashes);
+
+        Ok(())
+    }
+
+    pub fn build_deposit(
+        viewer: &mut PrepareTransactionViewer,
+        context: &DepositContext,
+    ) -> Result<(), TxBuilderError> {
+        if context.receivers.is_empty() {
+            return Err(TxBuilderError::InvalidParameter(anyhow!(
+                "empty dao receivers"
+            )));
+        }
+        for receiver in &context.receivers {
+            let output = CellOutput::new_builder()
+                .capacity(receiver.capacity.pack())
+                .lock(receiver.lock_script.clone())
+                .type_(Some(DAO_TYPE_SCRIPT.clone()).pack())
+                .build();
+            viewer.tx.output(output);
+            viewer.tx.output_data(DEPOSIT_CELL_DATA.clone());
+        }
+
+        Ok(())
+    }
+}
+
+impl ScriptHandler for DaoScriptHandler {
+    fn prepare_transaction(
+        &self,
+        viewer: &mut PrepareTransactionViewer,
+        context: &mut dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if let Some(args) = context.as_any().downcast_ref::<DepositContext>() {
+            Self::build_deposit(viewer, args)?;
+            Ok(true)
+        } else if let Some(args) = context.as_any().downcast_ref::<WithdrawPhrase1Context>() {
+            Self::build_phrase1_base(viewer, args)?;
+            Ok(true)
+        } else if let Some(args) = context.as_mut().downcast_mut::<WithdrawPhrase2Context>() {
+            Self::build_phrase2_base(viewer, args)?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+    fn build_transaction(
+        &self,
+        tx_builder: &mut crate::core::TransactionBuilder,
+        script_group: &ScriptGroup,
+        context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if !self.is_match(&script_group.script) {
+            return Ok(false);
+        }
+        if context.as_any().is::<DepositContext>()
+            || context.as_any().is::<WithdrawPhrase1Context>()
+        {
+            tx_builder.dedup_cell_deps(self.cell_deps.clone());
+            Ok(true)
+        } else if let Some(args) = context.as_any().downcast_ref::<WithdrawPhrase2Context>() {
+            tx_builder.dedup_cell_deps(self.cell_deps.clone());
+            if let Some(idx) = script_group.input_indices.last() {
+                if let Some((dep_header_idx, since)) = args.deposit_header_indexes.get(idx) {
+                    let idx_data =
+                        bytes::Bytes::from((*dep_header_idx as u64).to_le_bytes().to_vec());
+                    tx_builder.set_witness_input(*idx, Some(idx_data));
+                    tx_builder.set_input_since(*idx, *since);
+                }
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn init(&mut self, network: &NetworkInfo) -> Result<(), TxBuilderError> {
+        let out_point = if network.network_type == NetworkType::Mainnet {
+            OutPoint::new_builder()
+                .tx_hash(
+                    h256!("0xe2fb199810d49a4d8beec56718ba2593b665db9d52299a0f9e6e75416d73ff5c")
+                        .pack(),
+                )
+                .index(2u32.pack())
+                .build()
+        } else if network.network_type == NetworkType::Testnet {
+            OutPoint::new_builder()
+                .tx_hash(
+                    h256!("0x8f8c79eb6671709633fe6a46de93c0fedc9c1b8a6527a18d3983879542635c9f")
+                        .pack(),
+                )
+                .index(2u32.pack())
+                .build()
+        } else {
+            return Err(TxBuilderError::UnsupportedNetworkType(network.network_type));
+        };
+
+        let cell_dep = CellDep::new_builder()
+            .out_point(out_point)
+            .dep_type(DepType::Code.into())
+            .build();
+        self.cell_deps.push(cell_dep);
+        Ok(())
+    }
+}
diff --git a/src/transaction/handler/mod.rs b/src/transaction/handler/mod.rs
index 4a96bd34..3e53c9b6 100644
--- a/src/transaction/handler/mod.rs
+++ b/src/transaction/handler/mod.rs
@@ -7,10 +7,24 @@ use crate::{
 
 use self::sighash::Secp256k1Blake160SighashAllScriptContext;
 
+use super::builder::PrepareTransactionViewer;
+
+pub mod dao;
 pub mod multisig;
+pub mod omnilock;
 pub mod sighash;
+pub mod typeid;
+pub mod udt;
 
 pub trait ScriptHandler {
+    fn prepare_transaction(
+        &self,
+        _viewer: &mut PrepareTransactionViewer,
+        _context: &mut dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        Ok(false)
+    }
+
     /// Try to build transaction with the given script_group and context.
     ///
     /// Return true if script_group and context are matched, otherwise return false.
@@ -21,17 +35,30 @@ pub trait ScriptHandler {
         context: &dyn HandlerContext,
     ) -> Result<bool, TxBuilderError>;
 
+    fn post_build(
+        &self,
+        _index: usize,
+        _tx_builder: &mut TransactionBuilder,
+        _context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        Ok(false)
+    }
     fn init(&mut self, network: &NetworkInfo) -> Result<(), TxBuilderError>;
 }
 
 pub trait Type2Any: 'static {
     fn as_any(&self) -> &dyn Any;
+    fn as_mut(&mut self) -> &mut dyn Any;
 }
 
 impl<T: 'static> Type2Any for T {
     fn as_any(&self) -> &dyn Any {
         self
     }
+
+    fn as_mut(&mut self) -> &mut dyn Any {
+        self
+    }
 }
 
 pub trait HandlerContext: Type2Any {}
@@ -43,12 +70,20 @@ pub struct HandlerContexts {
 impl Default for HandlerContexts {
     fn default() -> Self {
         Self {
-            contexts: vec![Box::new(Secp256k1Blake160SighashAllScriptContext {})],
+            contexts: vec![
+                Box::new(Secp256k1Blake160SighashAllScriptContext {}),
+                Box::new(typeid::TypeIdContext {}),
+            ],
         }
     }
 }
 
 impl HandlerContexts {
+    pub fn new(context: Box<dyn HandlerContext>) -> Self {
+        Self {
+            contexts: vec![context],
+        }
+    }
     pub fn new_sighash() -> Self {
         Self {
             contexts: vec![Box::new(Secp256k1Blake160SighashAllScriptContext {})],
@@ -63,7 +98,38 @@ impl HandlerContexts {
         }
     }
 
-    pub fn add_context(mut self, context: Box<dyn HandlerContext>) {
+    pub fn new_dao_withdraw_phrase1() -> Self {
+        Self {
+            contexts: vec![Box::<dao::WithdrawPhrase1Context>::default()],
+        }
+    }
+
+    pub fn new_dao_withdraw_phrase2() -> Self {
+        Self {
+            contexts: vec![Box::<dao::WithdrawPhrase1Context>::default()],
+        }
+    }
+
+    pub fn add_context(&mut self, context: Box<dyn HandlerContext>) {
         self.contexts.push(context);
     }
+
+    /// extend this context with other contexts
+    pub fn extend_contexts(&mut self, contexts: HandlerContexts) {
+        self.contexts.extend(contexts.contexts);
+    }
+}
+
+macro_rules! cell_dep {
+    ($hash: literal, $idx: expr, $dep_type: expr) => {{
+        let out_point = ckb_types::packed::OutPoint::new_builder()
+            .tx_hash(ckb_types::h256!($hash).pack())
+            .index($idx.pack())
+            .build();
+        ckb_types::packed::CellDep::new_builder()
+            .out_point(out_point)
+            .dep_type($dep_type.into())
+            .build()
+    }};
 }
+pub(crate) use cell_dep;
diff --git a/src/transaction/handler/multisig.rs b/src/transaction/handler/multisig.rs
index 046078bb..e9755893 100644
--- a/src/transaction/handler/multisig.rs
+++ b/src/transaction/handler/multisig.rs
@@ -55,8 +55,8 @@ impl ScriptHandler for Secp256k1Blake160MultisigAllScriptHandler {
         {
             tx_builder.dedup_cell_deps(self.cell_deps.clone());
             let index = script_group.input_indices.first().unwrap();
-            let witness = args.multisig_config.placeholder_witness();
-            tx_builder.set_witness(*index, witness.as_bytes().pack());
+            let witness_lock = args.multisig_config.placeholder_witness_lock();
+            tx_builder.set_witness_lock(*index, witness_lock);
             Ok(true)
         } else {
             Ok(false)
diff --git a/src/transaction/handler/omnilock.rs b/src/transaction/handler/omnilock.rs
new file mode 100644
index 00000000..f224831d
--- /dev/null
+++ b/src/transaction/handler/omnilock.rs
@@ -0,0 +1,203 @@
+use ckb_types::{
+    core::DepType,
+    h256,
+    packed::{CellDep, OutPoint, Script},
+    prelude::{Builder, Entity, Pack},
+};
+
+use super::{cell_dep, HandlerContext, ScriptHandler};
+use crate::{
+    core::TransactionBuilder,
+    traits::DefaultTransactionDependencyProvider,
+    transaction::{builder::PrepareTransactionViewer, input::TransactionInput},
+    tx_builder::TxBuilderError,
+    unlock::{OmniLockConfig, OmniUnlockMode},
+    NetworkInfo, NetworkType, ScriptGroup, ScriptId,
+};
+use lazy_static::lazy_static;
+
+pub struct OmnilockScriptHandler {
+    cell_deps: Vec<CellDep>,
+    sighash_dep: CellDep,
+    multisig_dep: CellDep,
+    lock_script_id: ScriptId,
+}
+
+pub struct OmnilockScriptContext {
+    pub cfg: OmniLockConfig,
+    pub rce_cells: Option<Vec<OutPoint>>,
+    pub unlock_mode: OmniUnlockMode,
+    pub rpc_url: String,
+}
+
+impl OmnilockScriptContext {
+    pub fn new(cfg: OmniLockConfig, rpc_url: String) -> Self {
+        Self {
+            cfg,
+            rce_cells: None,
+            unlock_mode: OmniUnlockMode::Normal,
+            rpc_url,
+        }
+    }
+}
+
+impl HandlerContext for OmnilockScriptContext {}
+
+impl OmnilockScriptHandler {
+    pub fn is_match(&self, script: &Script) -> bool {
+        ScriptId::from(script) == self.lock_script_id
+    }
+
+    pub fn new_with_network(network: &NetworkInfo) -> Result<Self, TxBuilderError> {
+        let mut ret = Self {
+            cell_deps: vec![],
+            sighash_dep: Default::default(),
+            multisig_dep: Default::default(),
+            lock_script_id: ScriptId::default(),
+        };
+        ret.init(network)?;
+        Ok(ret)
+    }
+
+    pub fn set_cell_deps(&mut self, cell_deps: Vec<CellDep>) {
+        self.cell_deps = cell_deps;
+    }
+
+    pub fn set_lock_script_id(&mut self, lock_script_id: ScriptId) {
+        self.lock_script_id = lock_script_id;
+    }
+
+    fn build_base(
+        &self,
+        viewer: &mut PrepareTransactionViewer,
+        context: &OmnilockScriptContext,
+    ) -> Result<(), TxBuilderError> {
+        if let Some(admin_cfg) = context.cfg.get_admin_config() {
+            if let Some(rce_cells) = context.rce_cells.as_ref() {
+                if admin_cfg.rce_in_input() {
+                    let tx_dep_provider =
+                        DefaultTransactionDependencyProvider::new(&context.rpc_url, 10);
+                    for cell in rce_cells {
+                        let (input_cell, data) = tx_dep_provider.get_cell_with_data(cell)?;
+                        let transaction_input =
+                            TransactionInput::new(input_cell, data, cell.clone());
+                        viewer.transaction_inputs.push(transaction_input);
+                    }
+                } else {
+                    for cell in rce_cells {
+                        let cell_dep = CellDep::new_builder()
+                            .out_point(cell.clone())
+                            .dep_type(DepType::Code.into())
+                            .build();
+                        viewer.tx.dedup_cell_dep(cell_dep);
+                    }
+                }
+            }
+        }
+        let id_flag = if let Some(admin_cfg) = context.cfg.get_admin_config() {
+            admin_cfg.get_auth().flag()
+        } else {
+            context.cfg.id().flag()
+        };
+        match id_flag {
+            crate::unlock::IdentityFlag::PubkeyHash |
+            // ethereum only need secp256k1_data, and sighash group_dep contains it.
+            crate::unlock::IdentityFlag::Ethereum => {
+                    viewer.tx.dedup_cell_dep(self.sighash_dep.clone());
+            },
+            crate::unlock::IdentityFlag::Multisig => {
+                   viewer.tx.dedup_cell_dep(self.multisig_dep.clone());
+            },
+            crate::unlock::IdentityFlag::OwnerLock => {},
+            _ => todo!(),
+        }
+        Ok(())
+    }
+}
+
+impl ScriptHandler for OmnilockScriptHandler {
+    fn prepare_transaction(
+        &self,
+        viewer: &mut PrepareTransactionViewer,
+        context: &mut dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if let Some(args) = context.as_any().downcast_ref::<OmnilockScriptContext>() {
+            self.build_base(viewer, args)?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+    fn build_transaction(
+        &self,
+        tx_builder: &mut TransactionBuilder,
+        script_group: &ScriptGroup,
+        context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if !self.is_match(&script_group.script) {
+            return Ok(false);
+        }
+        if let Some(args) = context.as_any().downcast_ref::<OmnilockScriptContext>() {
+            tx_builder.dedup_cell_deps(self.cell_deps.clone());
+            let index = script_group.input_indices.first().unwrap();
+            let placeholder_witness = args.cfg.placeholder_witness(args.unlock_mode)?;
+            if let Some(lock) = placeholder_witness.lock().to_opt() {
+                tx_builder.set_witness_lock(*index, Some(lock.raw_data()));
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn init(&mut self, network: &NetworkInfo) -> Result<(), TxBuilderError> {
+        if network.network_type == NetworkType::Mainnet {
+            self.cell_deps.push(cell_dep!(
+                "0xdfdb40f5d229536915f2d5403c66047e162e25dedd70a79ef5164356e1facdc8",
+                0u32,
+                DepType::Code
+            ));
+            self.lock_script_id = MAINNET_OMNILOCK_SCRIPT_ID.clone();
+
+            self.sighash_dep = cell_dep!(
+                "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c",
+                0u32,
+                DepType::DepGroup
+            );
+            self.multisig_dep = cell_dep!(
+                "0x71a7ba8fc96349fea0ed3a5c47992e3b4084b031a42264a018e0072e8172e46c",
+                1u32,
+                DepType::DepGroup
+            );
+        } else if network.network_type == NetworkType::Testnet {
+            self.cell_deps.push(cell_dep!(
+                "0x27b62d8be8ed80b9f56ee0fe41355becdb6f6a40aeba82d3900434f43b1c8b60",
+                0u32,
+                DepType::Code
+            ));
+            self.lock_script_id = TESTNET_OMNILOCK_SCRIPT_ID.clone();
+            self.sighash_dep = cell_dep!(
+                "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37",
+                0u32,
+                DepType::DepGroup
+            );
+            self.multisig_dep = cell_dep!(
+                "0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37",
+                1u32,
+                DepType::DepGroup
+            );
+        } else {
+            return Err(TxBuilderError::UnsupportedNetworkType(network.network_type));
+        };
+        Ok(())
+    }
+}
+
+lazy_static! {
+    pub static ref MAINNET_OMNILOCK_SCRIPT_ID: ScriptId = ScriptId::new_type(h256!(
+        "0x9b819793a64463aed77c615d6cb226eea5487ccfc0783043a587254cda2b6f26"
+    ));
+    pub static ref TESTNET_OMNILOCK_SCRIPT_ID: ScriptId = ScriptId::new_type(h256!(
+        "0xf329effd1c475a2978453c8600e1eaf0bc2087ee093c3ee64cc96ec6847752cb"
+    ));
+}
diff --git a/src/transaction/handler/sighash.rs b/src/transaction/handler/sighash.rs
index 51a8308c..159d724e 100644
--- a/src/transaction/handler/sighash.rs
+++ b/src/transaction/handler/sighash.rs
@@ -1,7 +1,7 @@
 use ckb_types::{
     core::DepType,
     h256,
-    packed::{CellDep, OutPoint, Script, WitnessArgs},
+    packed::{CellDep, OutPoint, Script},
     prelude::{Builder, Entity, Pack},
 };
 
@@ -47,10 +47,7 @@ impl ScriptHandler for Secp256k1Blake160SighashAllScriptHandler {
         {
             tx_builder.dedup_cell_deps(self.cell_deps.clone());
             let index = script_group.input_indices.first().unwrap();
-            let witness = WitnessArgs::new_builder()
-                .lock(Some(bytes::Bytes::from(vec![0u8; 65])).pack())
-                .build();
-            tx_builder.set_witness(*index, witness.as_bytes().pack());
+            tx_builder.set_witness_lock(*index, Some(bytes::Bytes::from(vec![0u8; 65])));
             Ok(true)
         } else {
             Ok(false)
diff --git a/src/transaction/handler/typeid.rs b/src/transaction/handler/typeid.rs
new file mode 100644
index 00000000..0ffe5e2d
--- /dev/null
+++ b/src/transaction/handler/typeid.rs
@@ -0,0 +1,104 @@
+use ckb_hash::new_blake2b;
+use ckb_types::{
+    packed::{CellInput, Script},
+    prelude::*,
+};
+
+use crate::{
+    core::TransactionBuilder, tx_builder::TxBuilderError, NetworkInfo, ScriptGroup,
+    ScriptGroupType, ScriptId,
+};
+
+use super::{HandlerContext, ScriptHandler};
+
+pub struct TypeIdHandler;
+
+pub struct TypeIdContext {}
+
+impl HandlerContext for TypeIdContext {}
+
+impl TypeIdHandler {
+    pub fn is_match(&self, script: &Script) -> bool {
+        ScriptId::from(script).is_type_id()
+    }
+}
+
+// copy from https://github.com/nervosnetwork/ckb-cli/blob/develop/src/utils/other.rs#L325
+pub fn calculate_type_id(first_cell_input: &CellInput, output_index: u64) -> [u8; 32] {
+    let mut blake2b = new_blake2b();
+    blake2b.update(first_cell_input.as_slice());
+    blake2b.update(&output_index.to_le_bytes());
+    let mut ret = [0u8; 32];
+    blake2b.finalize(&mut ret);
+    ret
+}
+
+impl ScriptHandler for TypeIdHandler {
+    fn build_transaction(
+        &self,
+        tx_builder: &mut TransactionBuilder,
+        script_group: &ScriptGroup,
+        context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if script_group.group_type != ScriptGroupType::Type
+            || !self.is_match(&script_group.script)
+            || script_group.output_indices.is_empty()
+        {
+            return Ok(false);
+        }
+        if let Some(_args) = context.as_any().downcast_ref::<TypeIdContext>() {
+            let index = script_group.output_indices.last().unwrap();
+            let output = tx_builder.get_outputs()[*index].clone();
+            if let Some(type_) = output.type_().to_opt() {
+                if self.is_match(&type_) && type_.args().is_empty() {
+                    let type_ = type_
+                        .as_builder()
+                        .args(bytes::Bytes::from(vec![0u8; 32]).pack())
+                        .build();
+                    let output = output.as_builder().type_(Some(type_).pack()).build();
+                    tx_builder.set_output(*index, output);
+                }
+
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
+    fn init(&mut self, _network: &NetworkInfo) -> Result<(), TxBuilderError> {
+        Ok(())
+    }
+
+    fn post_build(
+        &self,
+        index: usize,
+        tx_builder: &mut TransactionBuilder,
+        _context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if let Some(output) = tx_builder.get_outputs().get(index) {
+            if let Some(type_) = output.type_().to_opt() {
+                if self.is_match(&type_) {
+                    if type_.args().raw_data()[..] == [0u8; 32] {
+                        let input = tx_builder
+                            .get_inputs()
+                            .get(0)
+                            .ok_or(TxBuilderError::InvalidInputIndex(0))?;
+                        let args = calculate_type_id(input, index as u64);
+                        let type_ = type_
+                            .as_builder()
+                            .args(bytes::Bytes::from(args.to_vec()).pack())
+                            .build();
+                        let output = output
+                            .clone()
+                            .as_builder()
+                            .type_(Some(type_).pack())
+                            .build();
+                        tx_builder.set_output(index, output);
+                    }
+                    return Ok(true);
+                }
+            }
+        }
+        Ok(false)
+    }
+}
diff --git a/src/transaction/handler/udt.rs b/src/transaction/handler/udt.rs
new file mode 100644
index 00000000..7b60dd25
--- /dev/null
+++ b/src/transaction/handler/udt.rs
@@ -0,0 +1,539 @@
+use anyhow::anyhow;
+use bytes::{BufMut, BytesMut};
+use ckb_types::{
+    bytes,
+    core::{Capacity, DepType},
+    h256,
+    packed::{CellDep, CellOutput, OutPoint, Script},
+    prelude::{Builder, Entity, Pack},
+    H256,
+};
+
+use lazy_static::lazy_static;
+
+use crate::{
+    core::TransactionBuilder,
+    traits::{CellCollector, CellQueryOptions, DefaultCellCollector, LiveCell, ValueRangeOption},
+    transaction::{builder::PrepareTransactionViewer, input::TransactionInput},
+    tx_builder::{udt::UdtType, TransferAction, TxBuilderError},
+    NetworkInfo, NetworkType, ScriptGroup, ScriptGroupType, ScriptId,
+};
+
+use super::{HandlerContext, ScriptHandler};
+
+lazy_static! {
+    // Nervos implemented environment
+    static ref MAINNET_SUDT_SCRIPT_ID: ScriptId = ScriptId::new_type(h256!("0x5e7a36a77e68eecc013dfa2fe6a23f3b6c344b04005808694ae6dd45eea4cfd5"));
+    static ref TESTNET_SUDT_SCRIPT_ID: ScriptId = ScriptId::new_type(h256!("0xc5e5dcf215925f7ef4dfaf5f4b4f105bc321c02776d6e7d52a1db3fcd9d011a4"));
+}
+
+pub struct UdtScriptHandler {
+    cell_deps: Vec<CellDep>,
+    script_id: ScriptId,
+}
+
+/// The udt issue/transfer receiver
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct UdtTargetReceiver {
+    pub action: TransferAction,
+
+    /// The lock script set to this udt cell, if `action` is `Update` will query
+    /// input cell by this lock script.
+    pub lock_script: Script,
+
+    /// The capacity set to this udt cell when `action` is TransferAction::Create
+    pub capacity: Option<u64>,
+
+    /// The amount to issue/transfer
+    pub amount: u128,
+
+    /// Only for <xudt data> and only used when action == TransferAction::Create
+    pub extra_data: Option<bytes::Bytes>,
+}
+
+pub struct ReceiverBuildOutput {
+    pub input: Option<TransactionInput>,
+    pub output: CellOutput,
+    pub output_data: bytes::Bytes,
+}
+
+impl UdtTargetReceiver {
+    pub fn new(action: TransferAction, lock_script: Script, amount: u128) -> UdtTargetReceiver {
+        UdtTargetReceiver {
+            action,
+            lock_script,
+            capacity: None,
+            amount,
+            extra_data: None,
+        }
+    }
+
+    pub fn build(
+        &self,
+        type_script: &Script,
+        cell_collector: &mut dyn CellCollector,
+    ) -> Result<ReceiverBuildOutput, TxBuilderError> {
+        match self.action {
+            TransferAction::Create => {
+                let data_len = self
+                    .extra_data
+                    .as_ref()
+                    .map(|data| data.len())
+                    .unwrap_or_default()
+                    + 16;
+                let mut data = BytesMut::with_capacity(data_len);
+                data.put(&self.amount.to_le_bytes()[..]);
+                if let Some(extra_data) = self.extra_data.as_ref() {
+                    data.put(extra_data.as_ref());
+                }
+
+                let base_output = CellOutput::new_builder()
+                    .lock(self.lock_script.clone())
+                    .type_(Some(type_script.clone()).pack())
+                    .build();
+                let base_occupied_capacity = base_output
+                    .occupied_capacity(Capacity::bytes(data_len).unwrap())
+                    .unwrap()
+                    .as_u64();
+                let final_capacity = if let Some(capacity) = self.capacity.as_ref() {
+                    if *capacity >= base_occupied_capacity {
+                        *capacity
+                    } else {
+                        return Err(TxBuilderError::Other(anyhow!(
+                            "Not enough capacity to hold a receiver cell, min: {}, actual: {}",
+                            base_occupied_capacity,
+                            *capacity,
+                        )));
+                    }
+                } else {
+                    base_occupied_capacity
+                };
+                let output = base_output
+                    .as_builder()
+                    .capacity(final_capacity.pack())
+                    .build();
+                Ok(ReceiverBuildOutput {
+                    input: None,
+                    output,
+                    output_data: data.freeze(),
+                })
+            }
+            TransferAction::Update => {
+                let receiver_query = {
+                    let mut query = CellQueryOptions::new_lock(self.lock_script.clone());
+                    query.secondary_script = Some(type_script.clone());
+                    query.data_len_range = Some(ValueRangeOption::new_min(16));
+                    query
+                };
+                let (receiver_cells, _) =
+                    cell_collector.collect_live_cells(&receiver_query, true)?;
+                if receiver_cells.is_empty() {
+                    return Err(TxBuilderError::Other(anyhow!(
+                        "update receiver cell failed, cell not found, lock={:?}",
+                        self.lock_script
+                    )));
+                }
+
+                let mut amount_bytes = [0u8; 16];
+                let receiver_cell = receiver_cells.into_iter().next().unwrap();
+                amount_bytes.copy_from_slice(&receiver_cell.output_data.as_ref()[0..16]);
+                let old_amount = u128::from_le_bytes(amount_bytes);
+                let new_amount = old_amount + self.amount;
+                let mut new_data = receiver_cell.output_data.as_ref().to_vec();
+                new_data[0..16].copy_from_slice(&new_amount.to_le_bytes()[..]);
+                let output_data = bytes::Bytes::from(new_data);
+
+                Ok(ReceiverBuildOutput {
+                    output: receiver_cell.output.clone(),
+                    input: Some(receiver_cell.into()),
+                    output_data,
+                })
+            }
+        }
+    }
+}
+
+pub struct UdtIssueContext {
+    /// The udt type (sudt/xudt)
+    pub udt_type: UdtType,
+
+    /// The sudt/xudt script id
+    pub script_id: ScriptId,
+
+    /// We will collect a cell from owner, there must exists a cell that:
+    ///   * type script is None
+    ///   * data field is empty
+    ///   * is mature
+    pub owner: Script,
+
+    /// The receivers
+    pub receivers: Vec<UdtTargetReceiver>,
+    pub rpc_url: String,
+}
+
+impl UdtIssueContext {
+    // Create a sudt issue context, with type script mentioned in https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0025-simple-udt/0025-simple-udt.md,
+    // action is create.
+    pub fn new_default(
+        owner: Script,
+        receiver: Script,
+        amount: u128,
+        net_info: &NetworkInfo,
+    ) -> Self {
+        let receiver = UdtTargetReceiver {
+            action: TransferAction::Create,
+            lock_script: receiver,
+            capacity: None,
+            amount,
+            extra_data: None,
+        };
+        let script_id = if net_info.network_type == NetworkType::Mainnet {
+            (*MAINNET_SUDT_SCRIPT_ID).clone()
+        } else {
+            (*TESTNET_SUDT_SCRIPT_ID).clone()
+        };
+        Self {
+            udt_type: UdtType::Sudt,
+            script_id,
+            owner,
+            receivers: vec![receiver],
+            rpc_url: net_info.url.clone(),
+        }
+    }
+    pub fn new(
+        script_id: ScriptId,
+        owner: Script,
+        receivers: Vec<UdtTargetReceiver>,
+        rpc_url: String,
+    ) -> Self {
+        Self {
+            udt_type: UdtType::Sudt,
+            script_id,
+            owner,
+            receivers,
+            rpc_url,
+        }
+    }
+    pub fn new_xudt(
+        bytes: bytes::Bytes,
+        script_id: ScriptId,
+        owner: Script,
+        receivers: Vec<UdtTargetReceiver>,
+        rpc_url: String,
+    ) -> Self {
+        Self {
+            udt_type: UdtType::Xudt(bytes),
+            script_id,
+            owner,
+            receivers,
+            rpc_url,
+        }
+    }
+}
+
+impl HandlerContext for UdtIssueContext {}
+pub struct UdtTransferContext {
+    /// The udt type script
+    pub type_script: Script,
+
+    /// Sender's lock script (we will asume there is only one udt cell identify
+    /// by `type_script` and `sender`)
+    pub sender: Script,
+
+    // If not set, use original lock script, otherwise use this one.
+    pub udt_change_lock: Option<Script>,
+
+    /// The transfer receivers
+    pub receivers: Vec<UdtTargetReceiver>,
+    /// after transfer if amount is 0, should we keep the cell, or transfer the capacity to change cell.
+    /// default is true, then it will keep a cell with 0 amount, next time transfer will use this 0 amount cell as input.
+    pub keep_zero_udt_cell: bool,
+    pub rpc_url: String,
+}
+
+impl UdtTransferContext {
+    pub fn new(
+        type_script: Script,
+        sender: Script,
+        receivers: Vec<UdtTargetReceiver>,
+        rpc_url: String,
+    ) -> Self {
+        Self {
+            type_script,
+            sender,
+            udt_change_lock: None,
+            receivers,
+            keep_zero_udt_cell: true,
+            rpc_url,
+        }
+    }
+    // Create a transafer from owner address, with  type script mentioned in https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0025-simple-udt/0025-simple-udt.md,
+    // action is create.
+    pub fn from_owner(
+        owner: &Script,
+        sender: Script,
+        receiver: Script,
+        amount: u128,
+        net_info: &NetworkInfo,
+    ) -> Self {
+        let receiver = UdtTargetReceiver {
+            action: TransferAction::Create,
+            lock_script: receiver,
+            capacity: None,
+            amount,
+            extra_data: None,
+        };
+        let script_id = if net_info.network_type == NetworkType::Mainnet {
+            (*MAINNET_SUDT_SCRIPT_ID).clone()
+        } else {
+            (*TESTNET_SUDT_SCRIPT_ID).clone()
+        };
+        let owner_lock_hash = owner.calc_script_hash();
+        let type_script = UdtType::Sudt.build_script(&script_id, &owner_lock_hash);
+        Self {
+            type_script,
+            sender,
+            udt_change_lock: None,
+            receivers: vec![receiver],
+            keep_zero_udt_cell: true,
+            rpc_url: net_info.url.clone(),
+        }
+    }
+    pub fn set_udt_change_lock(&mut self, udt_change_lock: Option<Script>) {
+        self.udt_change_lock = udt_change_lock;
+    }
+    pub fn set_keep_zero_udt_cell(&mut self, keep_zero_udt_cell: bool) {
+        self.keep_zero_udt_cell = keep_zero_udt_cell;
+    }
+}
+
+impl HandlerContext for UdtTransferContext {}
+
+impl UdtScriptHandler {
+    pub fn is_match(&self, script: &Script) -> bool {
+        ScriptId::from(script) == self.script_id
+    }
+    pub fn new_with_network(network: &NetworkInfo) -> Result<Self, TxBuilderError> {
+        let mut ret = Self {
+            cell_deps: vec![],
+            script_id: ScriptId::new_type(H256::default()),
+        };
+        ret.init(network)?;
+        Ok(ret)
+    }
+
+    pub fn set_script_id(&mut self, script_id: ScriptId) {
+        self.script_id = script_id;
+    }
+
+    pub fn set_cell_deps(&mut self, cell_deps: Vec<CellDep>) {
+        self.cell_deps = cell_deps;
+    }
+
+    fn build_issue_base(
+        viewer: &mut PrepareTransactionViewer,
+        context: &UdtIssueContext,
+    ) -> Result<(), TxBuilderError> {
+        let mut cell_collector = DefaultCellCollector::new(&context.rpc_url);
+
+        // Build output type script
+        let owner_lock_hash = context.owner.calc_script_hash();
+        let type_script = context
+            .udt_type
+            .build_script(&context.script_id, &owner_lock_hash);
+
+        // Build outputs, outputs_data, cell_deps
+        for receiver in &context.receivers {
+            let ReceiverBuildOutput {
+                input,
+                output,
+                output_data,
+            } = receiver.build(&type_script, &mut cell_collector)?;
+            if let Some(input) = input {
+                viewer.transaction_inputs.push(input);
+            }
+            viewer.tx.output(output);
+            viewer.tx.output_data(output_data.pack());
+        }
+        Ok(())
+    }
+
+    fn find_sender_cell(
+        context: &UdtTransferContext,
+        cell_collector: &mut dyn CellCollector,
+        output_total: u128,
+    ) -> Result<(Vec<LiveCell>, u128), TxBuilderError> {
+        let sender_query = {
+            let mut query = CellQueryOptions::new_lock(context.sender.clone());
+            query.secondary_script = Some(context.type_script.clone());
+            query.data_len_range = Some(ValueRangeOption::new_min(16));
+            query
+        };
+        let mut input_cells = vec![];
+
+        let mut input_total = 0;
+        loop {
+            let (sender_cells, _) = cell_collector.collect_live_cells(&sender_query, true)?;
+            if sender_cells.is_empty() {
+                break;
+            }
+            let mut amount_bytes = [0u8; 16];
+            let sender_cell = sender_cells.into_iter().next().unwrap();
+            amount_bytes.copy_from_slice(&sender_cell.output_data.as_ref()[0..16]);
+            input_cells.push(sender_cell);
+
+            let input_amount = u128::from_le_bytes(amount_bytes);
+            input_total += input_amount;
+            if input_total >= output_total {
+                return Ok((input_cells, input_total));
+            }
+        }
+        if input_cells.is_empty() {
+            return Err(TxBuilderError::Other(anyhow!(
+                "qualified sender cell not found"
+            )));
+        } else {
+            return Err(TxBuilderError::Other(anyhow!(
+                "sender udt amount not enough, expected at least: {}, actual: {}",
+                output_total,
+                input_total
+            )));
+        }
+    }
+
+    fn build_transfer_base(
+        viewer: &mut PrepareTransactionViewer,
+        context: &UdtTransferContext,
+    ) -> Result<(), TxBuilderError> {
+        let mut cell_collector = DefaultCellCollector::new(&context.rpc_url);
+        let output_total: u128 = context
+            .receivers
+            .iter()
+            .map(|receiver| receiver.amount)
+            .sum();
+
+        let (sender_cells, input_total) =
+            Self::find_sender_cell(context, &mut cell_collector, output_total)?;
+
+        for receiver in &context.receivers {
+            let ReceiverBuildOutput {
+                input,
+                output,
+                output_data,
+            } = receiver.build(&context.type_script, &mut cell_collector)?;
+            if let Some(input) = input {
+                viewer.transaction_inputs.push(input);
+            }
+            viewer.tx.output(output);
+            viewer.tx.output_data(output_data.pack());
+        }
+
+        let new_amount = input_total - output_total;
+        if new_amount > 0 || context.keep_zero_udt_cell {
+            let sender_output_data = {
+                let mut new_data = sender_cells[0].output_data.as_ref().to_vec();
+                new_data[0..16].copy_from_slice(&new_amount.to_le_bytes()[..]);
+                bytes::Bytes::from(new_data)
+            };
+
+            let mut output = sender_cells[0].output.clone();
+            if let Some(udt_lock) = context.udt_change_lock.as_ref() {
+                output = output.as_builder().lock(udt_lock.clone()).build();
+            }
+            viewer.tx.output(output);
+            viewer.tx.output_data(sender_output_data.pack());
+        }
+        sender_cells
+            .into_iter()
+            .map(|cell| cell.into())
+            .for_each(|input| viewer.transaction_inputs.push(input));
+        Ok(())
+    }
+}
+
+impl ScriptHandler for UdtScriptHandler {
+    fn prepare_transaction(
+        &self,
+        viewer: &mut PrepareTransactionViewer,
+        context: &mut dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if let Some(args) = context.as_any().downcast_ref::<UdtIssueContext>() {
+            if self.script_id != args.script_id {
+                return Ok(false);
+            }
+            Self::build_issue_base(viewer, args)?;
+            Ok(true)
+        } else if let Some(args) = context.as_any().downcast_ref::<UdtTransferContext>() {
+            if self.script_id != (&args.type_script).into() {
+                return Ok(false);
+            }
+            Self::build_transfer_base(viewer, args)?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+    fn build_transaction(
+        &self,
+        tx_builder: &mut TransactionBuilder,
+        script_group: &ScriptGroup,
+        context: &dyn HandlerContext,
+    ) -> Result<bool, TxBuilderError> {
+        if script_group.group_type != ScriptGroupType::Type || !self.is_match(&script_group.script)
+        {
+            return Ok(false);
+        }
+        if let Some(args) = context.as_any().downcast_ref::<UdtIssueContext>() {
+            // user may implemented it's own type script
+            if self.script_id != args.script_id {
+                return Ok(false);
+            }
+            tx_builder.dedup_cell_deps(self.cell_deps.clone());
+            Ok(true)
+        } else if let Some(args) = context.as_any().downcast_ref::<UdtTransferContext>() {
+            // user may implemented it's own type script
+            if self.script_id != (&args.type_script).into() {
+                return Ok(false);
+            }
+            tx_builder.dedup_cell_deps(self.cell_deps.clone());
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn init(&mut self, network: &NetworkInfo) -> Result<(), TxBuilderError> {
+        let out_point = if network.network_type == NetworkType::Mainnet {
+            OutPoint::new_builder()
+                .tx_hash(
+                    h256!("0xc7813f6a415144643970c2e88e0bb6ca6a8edc5dd7c1022746f628284a9936d5")
+                        .pack(),
+                )
+                .index(0u32.pack())
+                .build()
+        } else if network.network_type == NetworkType::Testnet {
+            OutPoint::new_builder()
+                .tx_hash(
+                    h256!("0xe12877ebd2c3c364dc46c5c992bcfaf4fee33fa13eebdf82c591fc9825aab769")
+                        .pack(),
+                )
+                .index(0u32.pack())
+                .build()
+        } else {
+            return Err(TxBuilderError::UnsupportedNetworkType(network.network_type));
+        };
+
+        let cell_dep = CellDep::new_builder()
+            .out_point(out_point)
+            .dep_type(DepType::Code.into())
+            .build();
+        self.cell_deps.push(cell_dep);
+
+        self.script_id = if network.network_type == NetworkType::Mainnet {
+            (*MAINNET_SUDT_SCRIPT_ID).clone()
+        } else {
+            (*TESTNET_SUDT_SCRIPT_ID).clone()
+        };
+        Ok(())
+    }
+}
diff --git a/src/transaction/input/mod.rs b/src/transaction/input/mod.rs
index fdf7284f..ca828f74 100644
--- a/src/transaction/input/mod.rs
+++ b/src/transaction/input/mod.rs
@@ -60,7 +60,7 @@ impl InputIterator {
         *buffer_inputs = live_cells
             .into_iter()
             .rev() // reverse the iter, so that the first cell will be consumed while pop
-            .map(|live_cell| TransactionInput::new(live_cell, 0))
+            .map(TransactionInput::from)
             .collect();
         Ok(capacity > 0)
     }
diff --git a/src/transaction/input/transaction_input.rs b/src/transaction/input/transaction_input.rs
index bed9d82c..56382039 100644
--- a/src/transaction/input/transaction_input.rs
+++ b/src/transaction/input/transaction_input.rs
@@ -7,28 +7,42 @@ use crate::traits::LiveCell;
 
 #[derive(Clone, Debug)]
 pub struct TransactionInput {
-    live_cell: LiveCell,
-    since: u64,
+    pub output: packed::CellOutput,
+    pub output_data: bytes::Bytes,
+    pub out_point: packed::OutPoint,
 }
 
 impl TransactionInput {
-    pub fn new(live_cell: LiveCell, since: u64) -> Self {
-        Self { live_cell, since }
+    pub fn new(
+        output: packed::CellOutput,
+        output_data: bytes::Bytes,
+        out_point: packed::OutPoint,
+    ) -> Self {
+        Self {
+            output,
+            output_data,
+            out_point,
+        }
     }
 
-    #[inline]
-    pub fn set_since(&mut self, since: u64) {
-        self.since = since;
-    }
-
-    pub fn cell_input(&self) -> packed::CellInput {
+    pub fn cell_input(&self, since: u64) -> packed::CellInput {
         packed::CellInput::new_builder()
-            .since(self.since.pack())
-            .previous_output(self.live_cell.out_point.clone())
+            .since(since.pack())
+            .previous_output(self.out_point.clone())
             .build()
     }
 
     pub fn previous_output(&self) -> &packed::CellOutput {
-        &self.live_cell.output
+        &self.output
+    }
+}
+
+impl From<LiveCell> for TransactionInput {
+    fn from(live_cell: LiveCell) -> Self {
+        Self {
+            output: live_cell.output,
+            output_data: live_cell.output_data,
+            out_point: live_cell.out_point,
+        }
     }
 }
diff --git a/src/transaction/mod.rs b/src/transaction/mod.rs
index ac2b315f..0568efcb 100644
--- a/src/transaction/mod.rs
+++ b/src/transaction/mod.rs
@@ -72,6 +72,12 @@ impl TransactionBuilderConfiguration {
                     network,
                 )?,
             ) as Box<_>,
+            Box::new(handler::dao::DaoScriptHandler::new_with_network(network)?) as Box<_>,
+            Box::new(handler::omnilock::OmnilockScriptHandler::new_with_network(
+                network,
+            )?) as Box<_>,
+            Box::new(handler::typeid::TypeIdHandler) as Box<_>,
+            Box::new(handler::udt::UdtScriptHandler::new_with_network(network)?) as Box<_>,
         ];
         Ok(ret)
     }
diff --git a/src/transaction/signer/mod.rs b/src/transaction/signer/mod.rs
index e4279caf..655a632b 100644
--- a/src/transaction/signer/mod.rs
+++ b/src/transaction/signer/mod.rs
@@ -3,14 +3,15 @@ use std::collections::HashMap;
 
 use crate::{
     constants,
-    unlock::{MultisigConfig, UnlockError},
-    NetworkInfo, ScriptGroup, ScriptId, TransactionWithScriptGroups,
+    unlock::{MultisigConfig, OmniLockConfig, UnlockError},
+    NetworkInfo, NetworkType, ScriptGroup, ScriptId, TransactionWithScriptGroups,
 };
 
 use self::sighash::Secp256k1Blake160SighashAllSigner;
 
 use super::handler::Type2Any;
 pub mod multisig;
+pub mod omnilock;
 pub mod sighash;
 
 pub trait CKBScriptSigner {
@@ -68,6 +69,13 @@ impl SignContexts {
         Ok(Self::new_multisig(key, multisig_config))
     }
 
+    pub fn new_omnilock(key: secp256k1::SecretKey, omnilock_config: OmniLockConfig) -> Self {
+        let omnilock_context = omnilock::OmnilockSignerContext::new(vec![key], omnilock_config);
+        Self {
+            contexts: vec![Box::new(omnilock_context)],
+        }
+    }
+
     #[inline]
     pub fn add_context(&mut self, context: Box<dyn SignContext>) {
         self.contexts.push(context);
@@ -79,7 +87,7 @@ pub struct TransactionSigner {
 }
 
 impl TransactionSigner {
-    pub fn new(_network: &NetworkInfo) -> Self {
+    pub fn new(network: &NetworkInfo) -> Self {
         let mut unlockers = HashMap::default();
 
         let sighash_script_id = ScriptId::new_type(constants::SIGHASH_TYPE_HASH.clone());
@@ -92,7 +100,21 @@ impl TransactionSigner {
             ScriptId::new_type(constants::MULTISIG_TYPE_HASH.clone()),
             Box::new(multisig::Secp256k1Blake160MultisigAllSigner {}) as Box<_>,
         );
-
+        match network.network_type {
+            NetworkType::Mainnet => unlockers.insert(
+                crate::transaction::handler::omnilock::MAINNET_OMNILOCK_SCRIPT_ID.clone(),
+                Box::new(omnilock::OmnilockSigner {}) as Box<_>,
+            ),
+            NetworkType::Testnet => unlockers.insert(
+                crate::transaction::handler::omnilock::TESTNET_OMNILOCK_SCRIPT_ID.clone(),
+                Box::new(omnilock::OmnilockSigner {}) as Box<_>,
+            ),
+            _ => unreachable!(),
+        };
+        unlockers.insert(
+            ScriptId::new_type(constants::MULTISIG_TYPE_HASH.clone()),
+            Box::new(omnilock::OmnilockSigner {}) as Box<_>,
+        );
         Self { unlockers }
     }
 
diff --git a/src/transaction/signer/omnilock.rs b/src/transaction/signer/omnilock.rs
new file mode 100644
index 00000000..b81b67bb
--- /dev/null
+++ b/src/transaction/signer/omnilock.rs
@@ -0,0 +1,62 @@
+use ckb_types::core;
+
+use crate::{
+    traits::{dummy_impls::DummyTransactionDependencyProvider, SecpCkbRawKeySigner},
+    unlock::{
+        OmniLockConfig, OmniLockScriptSigner, OmniLockUnlocker, OmniUnlockMode, ScriptUnlocker,
+        UnlockError,
+    },
+};
+
+use super::{CKBScriptSigner, SignContext};
+
+pub struct OmnilockSigner {}
+
+pub struct OmnilockSignerContext {
+    keys: Vec<secp256k1::SecretKey>,
+    cfg: OmniLockConfig,
+    unlock_mode: OmniUnlockMode,
+}
+
+impl OmnilockSignerContext {
+    pub fn new(keys: Vec<secp256k1::SecretKey>, cfg: OmniLockConfig) -> Self {
+        Self {
+            keys,
+            cfg,
+            unlock_mode: OmniUnlockMode::Normal,
+        }
+    }
+
+    pub fn build_multisig_unlocker(&self) -> OmniLockUnlocker {
+        let signer = SecpCkbRawKeySigner::new_with_secret_keys(self.keys.clone());
+        let omnilock_signer =
+            OmniLockScriptSigner::new(Box::new(signer), self.cfg.clone(), self.unlock_mode);
+        OmniLockUnlocker::new(omnilock_signer, self.cfg.clone())
+    }
+}
+
+impl SignContext for OmnilockSignerContext {}
+
+impl CKBScriptSigner for OmnilockSigner {
+    fn match_context(&self, context: &dyn SignContext) -> bool {
+        context.as_any().is::<OmnilockSignerContext>()
+    }
+    fn sign_transaction(
+        &self,
+        transaction: &core::TransactionView,
+        script_group: &crate::ScriptGroup,
+        context: &dyn super::SignContext,
+    ) -> Result<core::TransactionView, UnlockError> {
+        if let Some(args) = context.as_any().downcast_ref::<OmnilockSignerContext>() {
+            let unlocker = args.build_multisig_unlocker();
+            let tx = unlocker.unlock(
+                transaction,
+                script_group,
+                &DummyTransactionDependencyProvider {},
+            )?;
+            Ok(tx)
+        } else {
+            Err(UnlockError::SignContextTypeIncorrect)
+        }
+    }
+}
diff --git a/src/tx_builder/mod.rs b/src/tx_builder/mod.rs
index e1164047..fd4c822a 100644
--- a/src/tx_builder/mod.rs
+++ b/src/tx_builder/mod.rs
@@ -20,7 +20,6 @@ use ckb_types::{
     prelude::*,
 };
 
-use crate::types::ScriptGroup;
 use crate::types::{HumanCapacity, ScriptId};
 use crate::unlock::{ScriptUnlocker, UnlockError};
 use crate::util::calculate_dao_maximum_withdraw4;
@@ -32,6 +31,7 @@ use crate::{
     },
     RpcError,
 };
+use crate::{types::ScriptGroup, unlock::omni_lock::ConfigError};
 
 /// Transaction builder errors
 #[derive(Error, Debug)]
@@ -71,6 +71,12 @@ pub enum TxBuilderError {
     #[error("can not find specifed output to put small change")]
     NoOutputForSmallChange,
 
+    #[error("invalid input index: `{0}`")]
+    InvalidInputIndex(usize),
+
+    #[error("configuration error: `{0}`")]
+    ConfigError(#[from] ConfigError),
+
     #[error("other error: `{0}`")]
     Other(anyhow::Error),
 }
diff --git a/src/unlock/omni_lock.rs b/src/unlock/omni_lock.rs
index f9b5332e..faf3f1ab 100644
--- a/src/unlock/omni_lock.rs
+++ b/src/unlock/omni_lock.rs
@@ -7,6 +7,7 @@ use crate::{
         omni_lock::{Auth, Identity as IdentityType, IdentityOpt, OmniLockWitnessLock},
         xudt_rce_mol::SmtProofEntryVec,
     },
+    Address,
 };
 use ckb_types::{
     bytes::{BufMut, Bytes, BytesMut},
@@ -137,7 +138,7 @@ impl Identity {
             return Err("Not enough bytes to parse".to_string());
         }
         let flag = IdentityFlag::try_from(slice[0])
-            .map_err(|e| format!("can't parse {} to valide IdentityFlat.", e))?;
+            .map_err(|e| format!("can't parse {} to validate IdentityFlag.", e))?;
         let auth_content = H160::from_slice(&slice[1..21]).map_err(|e| e.to_string())?;
         Ok(Identity { flag, auth_content })
     }
@@ -167,6 +168,15 @@ impl From<Identity> for ckb_types::bytes::Bytes {
     }
 }
 
+impl Pack<Auth> for Identity {
+    fn pack(&self) -> Auth {
+        let mut temp = [0u8; Auth::TOTAL_SIZE];
+        temp[0] = self.flag as u8;
+        temp[1..21].copy_from_slice(self.auth_content.as_bytes());
+        Auth::from_slice(&temp).unwrap()
+    }
+}
+
 impl Display for Identity {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "(")?;
@@ -364,6 +374,16 @@ impl AdminConfig {
             rce_in_input,
         }
     }
+
+    pub fn from_type_id(rc_type_id: H256) -> Self {
+        AdminConfig {
+            rc_type_id,
+            proofs: SmtProofEntryVec::default(),
+            auth: Identity::default(),
+            multisig_config: None,
+            rce_in_input: false,
+        }
+    }
 }
 
 #[derive(Error, Debug)]
@@ -393,6 +413,16 @@ impl OmniLockAcpConfig {
             udt_minimum,
         }
     }
+
+    pub fn from_slice(bytes: &[u8]) -> Result<Self, String> {
+        if bytes.len() < 2 {
+            return Err(format!("expect minimum 2 bytes, got {}", bytes.len()));
+        }
+        Ok(Self {
+            ckb_minimum: bytes[0],
+            udt_minimum: bytes[1],
+        })
+    }
 }
 
 /// OmniLock configuration
@@ -417,7 +447,7 @@ pub struct OmniLockConfig {
     acp_config: Option<OmniLockAcpConfig>,
     /// 8 bytes since for time lock
     time_lock_config: Option<u64>,
-    // 32 bytes type script hash
+    // 32 bytes type script hash for supply mode.
     info_cell: Option<H256>,
 }
 
@@ -429,6 +459,56 @@ impl OmniLockConfig {
         Self::new(IdentityFlag::PubkeyHash, lock_arg)
     }
 
+    pub fn from_slice(args: &[u8]) -> Result<Self, String> {
+        let id = Identity::from_slice(args)?;
+        let omni_lock_flags = OmniLockFlags::from_bits(args[21]).unwrap_or(OmniLockFlags::empty());
+        let mut idx = 22;
+        let admin_config = if omni_lock_flags.contains(OmniLockFlags::ADMIN) {
+            let rc_type_id = H256::from_slice(&args[idx..])
+                .map_err(|e| format!("parse admin type id error {}", e))?;
+            idx += 32;
+            Some(AdminConfig::from_type_id(rc_type_id))
+        } else {
+            None
+        };
+        let acp_config = if omni_lock_flags.contains(OmniLockFlags::ACP) {
+            let acp_config = OmniLockAcpConfig::from_slice(&args[idx..])?;
+            idx += 2;
+            Some(acp_config)
+        } else {
+            None
+        };
+        let time_lock_config = if omni_lock_flags.contains(OmniLockFlags::TIME_LOCK) {
+            let mut time_bytes = [0u8; 8];
+            time_bytes.copy_from_slice(&args[idx..idx + 8]);
+            idx += 8;
+            let time = u64::from_le_bytes(time_bytes);
+            Some(time)
+        } else {
+            None
+        };
+        let info_cell = if omni_lock_flags.contains(OmniLockFlags::SUPPLY) {
+            let info_cell = H256::from_slice(&args[idx..])
+                .map_err(|e| format!("parse admin type id error {}", e))?;
+            Some(info_cell)
+        } else {
+            None
+        };
+        Ok(Self {
+            id,
+            multisig_config: None,
+            omni_lock_flags,
+            admin_config,
+            acp_config,
+            time_lock_config,
+            info_cell,
+        })
+    }
+
+    pub fn from_addr(addr: &Address) -> Result<Self, String> {
+        Self::from_slice(&addr.payload().args())
+    }
+
     pub fn new_multisig(multisig_config: MultisigConfig) -> Self {
         let blake160 = multisig_config.hash160();
         OmniLockConfig {
@@ -450,20 +530,15 @@ impl OmniLockConfig {
     ///
     /// * `pubkey_hash` - a ehtereum address of an account.
     ///
-    /// ```
-    /// // pubkey is a public ethereum address
-    /// use ckb_sdk::unlock::OmniLockConfig;
-    /// use ckb_sdk::util::keccak160;
-    /// use ckb_crypto::secp::Pubkey;
-    ///
-    /// let pubkey = Pubkey::from([0u8; 64]);
-    /// let pubkey_hash = keccak160(pubkey.as_ref());
-    /// let config = OmniLockConfig::new_ethereum(pubkey_hash);
-    /// ```
     pub fn new_ethereum(pubkey_hash: H160) -> Self {
         Self::new(IdentityFlag::Ethereum, pubkey_hash)
     }
 
+    pub fn new_ethereum_from_pubkey(pubkey: &ckb_crypto::secp::Pubkey) -> Self {
+        let pubkey_hash = crate::util::keccak160(pubkey.as_ref());
+        OmniLockConfig::new_ethereum(pubkey_hash)
+    }
+
     /// Create an ownerlock omnilock with according script hash.
     /// # Arguments
     /// * `script_hash` the proper blake160 hash of according ownerlock script.
@@ -539,6 +614,10 @@ impl OmniLockConfig {
         self.info_cell = None;
     }
 
+    pub fn set_multisig_config(&mut self, multisig_config: Option<MultisigConfig>) {
+        self.multisig_config = multisig_config;
+    }
+
     pub fn id(&self) -> &Identity {
         &self.id
     }
@@ -553,7 +632,7 @@ impl OmniLockConfig {
         &self.omni_lock_flags
     }
 
-    pub fn use_rc(&self) -> bool {
+    pub fn has_admin_config(&self) -> bool {
         self.admin_config.is_some()
     }
 
@@ -650,9 +729,28 @@ impl OmniLockConfig {
         &self,
         unlock_mode: OmniUnlockMode,
     ) -> Result<Bytes, ConfigError> {
-        let mut builder = match self.id.flag {
-            IdentityFlag::PubkeyHash | IdentityFlag::Ethereum => OmniLockWitnessLock::new_builder()
-                .signature(Some(Bytes::from(vec![0u8; 65])).pack()),
+        let mut builder = OmniLockWitnessLock::new_builder();
+        let mut auth_flag = self.id.flag;
+
+        if unlock_mode == OmniUnlockMode::Admin {
+            if let Some(config) = self.admin_config.as_ref() {
+                auth_flag = config.auth.flag;
+                let ident = IdentityType::new_builder()
+                    .identity(config.auth.pack())
+                    .proofs(config.proofs.clone())
+                    .build();
+
+                let ident_opt = IdentityOpt::new_builder().set(Some(ident)).build();
+                builder = builder.omni_identity(ident_opt);
+            } else {
+                return Err(ConfigError::NoAdminConfig);
+            }
+        }
+
+        builder = match auth_flag {
+            IdentityFlag::PubkeyHash | IdentityFlag::Ethereum => {
+                builder.signature(Some(Bytes::from(vec![0u8; 65])).pack())
+            }
             IdentityFlag::Multisig => {
                 let multisig_config = match unlock_mode {
                     OmniUnlockMode::Admin => self
@@ -671,29 +769,12 @@ impl OmniLockConfig {
                 let multisig_len = config_data.len() + multisig_config.threshold() as usize * 65;
                 let mut omni_sig = vec![0u8; multisig_len];
                 omni_sig[..config_data.len()].copy_from_slice(&config_data);
-                OmniLockWitnessLock::new_builder().signature(Some(Bytes::from(omni_sig)).pack())
+                builder.signature(Some(Bytes::from(omni_sig)).pack())
             }
-            IdentityFlag::OwnerLock => OmniLockWitnessLock::new_builder(),
+            IdentityFlag::OwnerLock => builder,
             _ => todo!("to support other placeholder_witness_lock implementions"),
         };
 
-        if unlock_mode == OmniUnlockMode::Admin {
-            if let Some(config) = self.admin_config.as_ref() {
-                let mut temp = [0u8; 21];
-                temp[0] = config.auth.flag as u8;
-                temp[1..21].copy_from_slice(config.auth.auth_content.as_bytes());
-                let auth = Auth::from_slice(&temp).unwrap();
-                let ident = IdentityType::new_builder()
-                    .identity(auth)
-                    .proofs(config.proofs.clone())
-                    .build();
-
-                let ident_opt = IdentityOpt::new_builder().set(Some(ident)).build();
-                builder = builder.omni_identity(ident_opt);
-            } else {
-                return Err(ConfigError::NoAdminConfig);
-            }
-        }
         Ok(builder.build().as_bytes())
     }
 
@@ -708,13 +789,22 @@ impl OmniLockConfig {
         &self,
         unlock_mode: OmniUnlockMode,
     ) -> Result<WitnessArgs, ConfigError> {
-        match self.id.flag {
+        let auth_flag = match unlock_mode {
+            OmniUnlockMode::Admin => {
+                self.get_admin_config()
+                    .ok_or(ConfigError::NoAdminConfig)?
+                    .auth
+                    .flag
+            }
+            OmniUnlockMode::Normal => self.id.flag,
+        };
+        match auth_flag {
             IdentityFlag::PubkeyHash | IdentityFlag::Ethereum | IdentityFlag::Multisig => {
                 let lock = self.placeholder_witness_lock(unlock_mode)?;
                 Ok(WitnessArgs::new_builder().lock(Some(lock).pack()).build())
             }
             IdentityFlag::OwnerLock => {
-                if self.admin_config.is_some() {
+                if unlock_mode == OmniUnlockMode::Admin {
                     let lock = self.placeholder_witness_lock(unlock_mode)?;
                     Ok(WitnessArgs::new_builder().lock(Some(lock).pack()).build())
                 } else {
diff --git a/src/unlock/signer.rs b/src/unlock/signer.rs
index 52a55b55..b86379cd 100644
--- a/src/unlock/signer.rs
+++ b/src/unlock/signer.rs
@@ -230,12 +230,16 @@ impl MultisigConfig {
     }
 
     pub fn placeholder_witness(&self) -> WitnessArgs {
+        WitnessArgs::new_builder()
+            .lock(self.placeholder_witness_lock().pack())
+            .build()
+    }
+
+    pub fn placeholder_witness_lock(&self) -> Option<bytes::Bytes> {
         let config_data = self.to_witness_data();
         let mut zero_lock = vec![0u8; config_data.len() + 65 * self.threshold() as usize];
         zero_lock[0..config_data.len()].copy_from_slice(config_data.as_ref());
-        WitnessArgs::new_builder()
-            .lock(Some(Bytes::from(zero_lock)).pack())
-            .build()
+        Some(Bytes::from(zero_lock))
     }
 
     pub fn to_address(&self, network: NetworkType, since_absolute_epoch: Option<u64>) -> Address {