From e3c04162d37915dd1cabc3dcd996fa95b893b476 Mon Sep 17 00:00:00 2001
From: dylan <duanyytop@gmail.com>
Date: Wed, 31 Jan 2024 15:22:42 +0800
Subject: [PATCH 1/2] add taker tests

---
 Cargo.lock                       |  69 ----------
 contracts/dex-lock/src/entry.rs  |   6 +-
 contracts/dex-lock/src/helper.rs |   2 +-
 tests/Cargo.toml                 |   5 +-
 tests/src/helper.rs              |  27 ++++
 tests/src/lib.rs                 |   4 +
 tests/src/taker_tests.rs         | 217 +++++++++++++++++++++++++++++++
 7 files changed, 254 insertions(+), 76 deletions(-)
 create mode 100644 tests/src/helper.rs
 create mode 100644 tests/src/taker_tests.rs

diff --git a/Cargo.lock b/Cargo.lock
index bcd7d76..0e85f7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -639,21 +639,6 @@ dependencies = [
  "miniz_oxide",
 ]
 
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "getrandom"
 version = "0.1.16"
@@ -894,45 +879,6 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
 
-[[package]]
-name = "openssl"
-version = "0.10.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b102428fd03bc5edf97f62620f7298614c45cedf287c271e7ed450bbaf83f2e1"
-dependencies = [
- "bitflags",
- "cfg-if",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23bbbf7854cd45b83958ebe919f0e8e516793727652e27fda10a8384cfc790b7"
-dependencies = [
- "autocfg",
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.12.1"
@@ -1000,12 +946,6 @@ dependencies = [
  "siphasher",
 ]
 
-[[package]]
-name = "pkg-config"
-version = "0.3.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
-
 [[package]]
 name = "plain"
 version = "0.2.3"
@@ -1287,12 +1227,9 @@ dependencies = [
 name = "tests"
 version = "0.1.0"
 dependencies = [
- "blake2b-rs",
  "ckb-testtool",
  "hex",
- "openssl",
  "rand 0.8.5",
- "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -1330,12 +1267,6 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
 
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
diff --git a/contracts/dex-lock/src/entry.rs b/contracts/dex-lock/src/entry.rs
index ce50f0b..dc068d4 100644
--- a/contracts/dex-lock/src/entry.rs
+++ b/contracts/dex-lock/src/entry.rs
@@ -22,8 +22,10 @@ pub fn main() -> Result<(), Error> {
     if args.owner_lock != output_lock {
         return Err(Error::DexOwnerLockNotMatch);
     }
-    let output_capacity = load_cell_capacity(dex_index, Source::Output)?;
-    if args.total_value > output_capacity.into() {
+
+    let dex_input_capacity = load_cell_capacity(dex_index, Source::Input)? as u128;
+    let output_capacity = load_cell_capacity(dex_index, Source::Output)? as u128;
+    if (args.total_value + dex_input_capacity) > output_capacity {
         return Err(Error::DexTotalValueNotMatch);
     }
 
diff --git a/contracts/dex-lock/src/helper.rs b/contracts/dex-lock/src/helper.rs
index f9d3937..8f2c961 100644
--- a/contracts/dex-lock/src/helper.rs
+++ b/contracts/dex-lock/src/helper.rs
@@ -29,7 +29,7 @@ impl DexArgs {
         }
         let owner_size = u32::from_le_bytes(parse_array::<4>(&data[0..4])?) as usize;
         let required_size = owner_size + 17;
-        if data.len() < (required_size + 17) {
+        if data.len() < required_size {
             return Err(Error::LockArgsInvalid);
         }
 
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 1615458..08ae6a8 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -5,8 +5,5 @@ edition = "2021"
 
 [dependencies]
 ckb-testtool = "0.10.1"
-rand_core = "0.6.3"
 hex = "0.4"
-blake2b-rs = "0.2"
-rand = "0.8.5"
-openssl = "0.10.38"
\ No newline at end of file
+rand = "0.8.5"
\ No newline at end of file
diff --git a/tests/src/helper.rs b/tests/src/helper.rs
new file mode 100644
index 0000000..da5ec2a
--- /dev/null
+++ b/tests/src/helper.rs
@@ -0,0 +1,27 @@
+#![allow(dead_code)]
+
+use ckb_testtool::ckb_types::{packed::Script, prelude::Entity};
+
+#[derive(Debug, Clone)]
+pub struct DexArgs {
+    pub owner_lock:     Script,
+    pub setup:          u8,
+    pub total_value:    u128,
+    pub receiver_lock:  Option<Script>,
+    pub unit_type_hash: Option<[u8; 20]>,
+}
+
+impl DexArgs {
+    pub fn to_vec(&self) -> Vec<u8> {
+        let mut ret: Vec<u8> = self.owner_lock.as_bytes().to_vec();
+        ret.extend([self.setup]);
+        ret.extend(self.total_value.to_be_bytes());
+        if let Some(lock) = &self.receiver_lock {
+            ret.extend(lock.as_bytes());
+        }
+        if let Some(unit_hash) = self.unit_type_hash {
+            ret.extend(unit_hash);
+        }
+        ret
+    }
+}
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index d28bdcc..009754f 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -5,6 +5,10 @@ use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
 
+mod helper;
+#[cfg(test)]
+mod taker_tests;
+
 const TEST_ENV_VAR: &str = "CAPSULE_TEST_ENV";
 
 pub enum TestEnv {
diff --git a/tests/src/taker_tests.rs b/tests/src/taker_tests.rs
new file mode 100644
index 0000000..3c203eb
--- /dev/null
+++ b/tests/src/taker_tests.rs
@@ -0,0 +1,217 @@
+use self::helper::DexArgs;
+
+use super::*;
+use ckb_testtool::builtin::ALWAYS_SUCCESS;
+use ckb_testtool::ckb_hash::blake2b_256;
+use ckb_testtool::ckb_types::{
+    bytes::Bytes,
+    core::{TransactionBuilder, TransactionView},
+    packed::*,
+    prelude::*,
+};
+use ckb_testtool::context::Context;
+use rand::{thread_rng, Rng};
+
+const MAX_CYCLES: u64 = 70_000_000;
+
+// error numbers
+const LOCK_ARGS_INVALID: i8 = 5;
+const DEX_OWNER_LOCK_NOT_MATCH: i8 = 6;
+const DEX_TOTAL_VALUE_NOT_MATCH: i8 = 7;
+const DEX_SETUP_INVALID: i8 = 8;
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum DexError {
+    NoError,
+    LockArgsInvalid,
+    DexOwnerLockNotMatch,
+    DexTotalValueNotMatch,
+    DexSetupInvalid,
+}
+
+fn create_test_context(error: DexError) -> (Context, TransactionView) {
+    // deploy contract
+    let mut context = Context::default();
+    let dex_bin: Bytes = Loader::default().load_binary("dex-lock");
+    let dex_out_point = context.deploy_cell(dex_bin);
+    let dex_dep = CellDep::new_builder()
+        .out_point(dex_out_point.clone())
+        .build();
+
+    let always_success_code_hash = blake2b_256(ALWAYS_SUCCESS.clone());
+    let always_success_out_point = context.deploy_cell(ALWAYS_SUCCESS.clone());
+    let always_success_dep = CellDep::new_builder()
+        .out_point(always_success_out_point.clone())
+        .build();
+
+    let mut rng = thread_rng();
+    let owner_lock1 = context
+        .build_script(
+            &always_success_out_point,
+            rng.gen::<[u8; 20]>().to_vec().into(),
+        )
+        .expect("script");
+    let owner_lock2 = context
+        .build_script(
+            &always_success_out_point,
+            rng.gen::<[u8; 20]>().to_vec().into(),
+        )
+        .expect("script");
+    let other_lock = context
+        .build_script(
+            &always_success_out_point,
+            rng.gen::<[u8; 20]>().to_vec().into(),
+        )
+        .expect("script");
+
+    let setup = if error == DexError::DexSetupInvalid {
+        3u8
+    } else {
+        0u8
+    };
+    let dex_args1 = DexArgs {
+        owner_lock: owner_lock1.clone(),
+        setup,
+        total_value: 1234_5678_0000u128,
+        receiver_lock: None,
+        unit_type_hash: None,
+    };
+    let dex_lock_script1 = context
+        .build_script(&dex_out_point, dex_args1.to_vec().into())
+        .expect("script");
+
+    let dex_args2 = DexArgs {
+        owner_lock:     owner_lock2.clone(),
+        setup:          0u8,
+        total_value:    9_8765_0000_1234u128,
+        receiver_lock:  None,
+        unit_type_hash: None,
+    };
+    let mut dex_args2_vec = dex_args2.to_vec();
+    if error == DexError::LockArgsInvalid {
+        dex_args2_vec.reverse();
+    }
+    let dex_lock_script2 = context
+        .build_script(&dex_out_point, dex_args2_vec.into())
+        .expect("script");
+
+    let asset_type = ScriptBuilder::default()
+        .code_hash(Byte32::from_slice(&always_success_code_hash).unwrap())
+        .hash_type(Byte::from(2u8))
+        .build();
+
+    let asset_amount1 = Bytes::try_from(1000_0000_0000u128.to_le_bytes().to_vec()).unwrap();
+    let input_out_point1 = context.create_cell(
+        CellOutput::new_builder()
+            .capacity(300_0000_0000u64.pack())
+            .lock(dex_lock_script1)
+            .type_(Some(asset_type.clone()).pack())
+            .build(),
+        asset_amount1.clone(),
+    );
+    let asset_amount2 = Bytes::try_from(3456_0000_0000u128.to_le_bytes().to_vec()).unwrap();
+    let input_out_point2 = context.create_cell(
+        CellOutput::new_builder()
+            .capacity(240_0000_0000u64.pack())
+            .lock(dex_lock_script2)
+            .type_(Some(asset_type.clone()).pack())
+            .build(),
+        asset_amount2.clone(),
+    );
+
+    let inputs = vec![
+        CellInput::new_builder()
+            .previous_output(input_out_point1)
+            .build(),
+        CellInput::new_builder()
+            .previous_output(input_out_point2)
+            .build(),
+    ];
+
+    let output1_capacity = if error == DexError::DexTotalValueNotMatch {
+        1234_5678_0000u64
+    } else {
+        1234_5678_0000u64 + 300_0000_0000u64
+    };
+    let output2_capacity = 9_8765_0000_1234u64 + 240_0000_0000u64;
+    let output2_lock = if error == DexError::DexOwnerLockNotMatch {
+        other_lock
+    } else {
+        owner_lock2
+    };
+    let outputs = vec![
+        CellOutput::new_builder()
+            .capacity(output1_capacity.pack())
+            .lock(owner_lock1)
+            .type_(Some(asset_type.clone()).pack())
+            .build(),
+        CellOutput::new_builder()
+            .capacity(output2_capacity.pack())
+            .lock(output2_lock)
+            .type_(Some(asset_type).pack())
+            .build(),
+    ];
+
+    let outputs_data = vec![asset_amount1, asset_amount2];
+
+    let mut witnesses = vec![];
+    for _ in 0..inputs.len() {
+        witnesses.push(Bytes::new())
+    }
+
+    let cell_deps = vec![always_success_dep, dex_dep];
+    // build transaction
+    let tx = TransactionBuilder::default()
+        .inputs(inputs)
+        .outputs(outputs)
+        .outputs_data(outputs_data.pack())
+        .cell_deps(cell_deps)
+        .witnesses(witnesses.pack())
+        .build();
+    let tx = context.complete_tx(tx);
+
+    // sign
+    (context, tx)
+}
+
+#[test]
+fn test_dex_taker_order_success() {
+    let (context, tx) = create_test_context(DexError::NoError);
+    // run
+    let cycles = context
+        .verify_tx(&tx, MAX_CYCLES)
+        .expect("pass verification");
+    println!("consume cycles: {}", cycles);
+}
+
+#[test]
+fn test_dex_taker_order_lock_args_error() {
+    let (context, tx) = create_test_context(DexError::LockArgsInvalid);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, LOCK_ARGS_INVALID);
+}
+
+#[test]
+fn test_dex_taker_order_owner_lock_not_match_error() {
+    let (context, tx) = create_test_context(DexError::DexOwnerLockNotMatch);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, DEX_OWNER_LOCK_NOT_MATCH);
+}
+
+#[test]
+fn test_dex_taker_order_total_value_not_match_error() {
+    let (context, tx) = create_test_context(DexError::DexTotalValueNotMatch);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, DEX_TOTAL_VALUE_NOT_MATCH);
+}
+
+#[test]
+fn test_dex_taker_order_total_setup_invalid_error() {
+    let (context, tx) = create_test_context(DexError::DexSetupInvalid);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, DEX_SETUP_INVALID);
+}

From fdf2a406109137f699279cd345a8001d39d3cec5 Mon Sep 17 00:00:00 2001
From: dylan <duanyytop@gmail.com>
Date: Wed, 31 Jan 2024 16:41:37 +0800
Subject: [PATCH 2/2] add cancel tests

---
 .github/workflows/rust.yml       |   6 +-
 Cargo.lock                       |  51 ++++-----
 capsule.toml                     |   2 +-
 contracts/dex-lock/Cargo.toml    |   2 +-
 contracts/dex-lock/src/entry.rs  |   3 +-
 contracts/dex-lock/src/helper.rs |   5 +-
 tests/Cargo.toml                 |   2 +-
 tests/src/cancel_tests.rs        | 188 +++++++++++++++++++++++++++++++
 tests/src/lib.rs                 |   2 +
 9 files changed, 222 insertions(+), 39 deletions(-)
 create mode 100644 tests/src/cancel_tests.rs

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index aed169b..871a501 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,12 +26,12 @@ jobs:
 
       - name: Install Capsule
         env:
-          CAPSULE_VERSION: v0.10.1
+          CAPSULE_VERSION: v0.10.3
         run: |
           sudo curl -OL https://github.com/nervosnetwork/capsule/releases/download/${CAPSULE_VERSION}/capsule_${CAPSULE_VERSION}_x86_64-linux.tar.gz && sudo tar xf capsule_${CAPSULE_VERSION}_x86_64-linux.tar.gz && echo `pwd`/capsule_${CAPSULE_VERSION}_x86_64-linux >> $GITHUB_PATH
 
       - name: Build contracts
-        run: make build-release
+        run: make build
 
       - name: Test contracts
-        run: make test-release
+        run: make test
diff --git a/Cargo.lock b/Cargo.lock
index 0e85f7f..ba9b909 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -117,7 +117,7 @@ dependencies = [
  "ckb-crypto",
  "ckb-dao-utils",
  "ckb-error",
- "ckb-hash 0.111.0",
+ "ckb-hash",
  "ckb-jsonrpc-types",
  "ckb-pow",
  "ckb-rational",
@@ -236,23 +236,12 @@ dependencies = [
  "cfg-if",
  "ckb-error",
  "ckb-fixed-hash",
- "ckb-hash 0.111.0",
+ "ckb-hash",
  "ckb-occupied-capacity",
  "molecule",
  "numext-fixed-uint",
 ]
 
-[[package]]
-name = "ckb-gen-types"
-version = "0.112.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a12020d50dd3757cde0fdc88d3837b7a2ab503fe38bd11be86ddace11318c77"
-dependencies = [
- "cfg-if",
- "ckb-hash 0.112.1",
- "molecule",
-]
-
 [[package]]
 name = "ckb-hash"
 version = "0.111.0"
@@ -263,15 +252,6 @@ dependencies = [
  "blake2b-rs",
 ]
 
-[[package]]
-name = "ckb-hash"
-version = "0.112.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25af660fc8746f7c756444e6aa47ede9a874206563b6a1ce1b230a5b86519392"
-dependencies = [
- "blake2b-ref",
-]
-
 [[package]]
 name = "ckb-jsonrpc-types"
 version = "0.111.0"
@@ -351,7 +331,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "481e76388993d7e6e0dd797e8532c60398901787e28d0638ca114254257b8813"
 dependencies = [
  "byteorder",
- "ckb-hash 0.111.0",
+ "ckb-hash",
  "ckb-types",
  "eaglesong",
  "log",
@@ -392,7 +372,7 @@ dependencies = [
  "byteorder",
  "ckb-chain-spec",
  "ckb-error",
- "ckb-hash 0.111.0",
+ "ckb-hash",
  "ckb-logger",
  "ckb-traits",
  "ckb-types",
@@ -401,15 +381,26 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "ckb-standalone-types"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5c776d70eb4f60a22a3180857646d77b2da8d33c0c4a063ad9f6610fc94609f"
+dependencies = [
+ "blake2b-ref",
+ "cfg-if",
+ "molecule",
+]
+
 [[package]]
 name = "ckb-std"
-version = "0.15.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "457042d634fe7c19ce60f9fc0c95d1c4ca823cc99581d4edb009105bb0534127"
+checksum = "2a08518aa0fd4ce069d3ec80b63dcd3d6543ad3805ad1c0b4e1d8e4d38f8a9fc"
 dependencies = [
  "buddy-alloc",
  "cc",
- "ckb-gen-types 0.112.1",
+ "ckb-standalone-types",
 ]
 
 [[package]]
@@ -441,7 +432,7 @@ dependencies = [
  "ckb-chain-spec",
  "ckb-crypto",
  "ckb-error",
- "ckb-hash 0.111.0",
+ "ckb-hash",
  "ckb-jsonrpc-types",
  "ckb-mock-tx-types",
  "ckb-resource",
@@ -474,8 +465,8 @@ dependencies = [
  "ckb-constant",
  "ckb-error",
  "ckb-fixed-hash",
- "ckb-gen-types 0.111.0",
- "ckb-hash 0.111.0",
+ "ckb-gen-types",
+ "ckb-hash",
  "ckb-merkle-mountain-range",
  "ckb-occupied-capacity",
  "ckb-rational",
diff --git a/capsule.toml b/capsule.toml
index 30d0247..a4f3266 100644
--- a/capsule.toml
+++ b/capsule.toml
@@ -1,4 +1,4 @@
-version = "0.10.1"
+version = "0.10.3"
 deployment = "deployment.toml"
 
 [[contracts]]
diff --git a/contracts/dex-lock/Cargo.toml b/contracts/dex-lock/Cargo.toml
index 551f433..753753a 100644
--- a/contracts/dex-lock/Cargo.toml
+++ b/contracts/dex-lock/Cargo.toml
@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-ckb-std = "0.15.0"
+ckb-std = "0.14.0"
diff --git a/contracts/dex-lock/src/entry.rs b/contracts/dex-lock/src/entry.rs
index dc068d4..0f60eca 100644
--- a/contracts/dex-lock/src/entry.rs
+++ b/contracts/dex-lock/src/entry.rs
@@ -4,6 +4,7 @@ use crate::{
 };
 use ckb_std::{
     ckb_constants::Source,
+    ckb_types::prelude::Entity,
     high_level::{load_cell_capacity, load_cell_lock},
 };
 
@@ -19,7 +20,7 @@ pub fn main() -> Result<(), Error> {
     // to the seller's lock script
     let dex_index = position_dex_lock_in_inputs()?;
     let output_lock = load_cell_lock(dex_index, Source::Output)?;
-    if args.owner_lock != output_lock {
+    if args.owner_lock.as_slice() != output_lock.as_slice() {
         return Err(Error::DexOwnerLockNotMatch);
     }
 
diff --git a/contracts/dex-lock/src/helper.rs b/contracts/dex-lock/src/helper.rs
index 8f2c961..33404cf 100644
--- a/contracts/dex-lock/src/helper.rs
+++ b/contracts/dex-lock/src/helper.rs
@@ -72,10 +72,11 @@ impl DexArgs {
 pub fn position_dex_lock_in_inputs() -> Result<usize, Error> {
     let current_lock = load_script()?;
     QueryIter::new(load_cell_lock, Source::Input)
-        .position(|lock| lock == current_lock)
+        .position(|lock| lock.as_slice() == current_lock.as_slice())
         .ok_or(Error::IndexOutOfBound)
 }
 
 pub fn inputs_contain_owner_cell(args: &DexArgs) -> bool {
-    QueryIter::new(load_cell_lock, Source::Input).any(|lock| lock == args.owner_lock)
+    QueryIter::new(load_cell_lock, Source::Input)
+        .any(|lock| lock.as_slice() == args.owner_lock.as_slice())
 }
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 08ae6a8..d9cb04b 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -4,6 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-ckb-testtool = "0.10.1"
+ckb-testtool = "0.10"
 hex = "0.4"
 rand = "0.8.5"
\ No newline at end of file
diff --git a/tests/src/cancel_tests.rs b/tests/src/cancel_tests.rs
new file mode 100644
index 0000000..e6f1eab
--- /dev/null
+++ b/tests/src/cancel_tests.rs
@@ -0,0 +1,188 @@
+use self::helper::DexArgs;
+
+use super::*;
+use ckb_testtool::builtin::ALWAYS_SUCCESS;
+use ckb_testtool::ckb_hash::blake2b_256;
+use ckb_testtool::ckb_types::{
+    bytes::Bytes,
+    core::{TransactionBuilder, TransactionView},
+    packed::*,
+    prelude::*,
+};
+use ckb_testtool::context::Context;
+use rand::{thread_rng, Rng};
+
+const MAX_CYCLES: u64 = 70_000_000;
+
+// error numbers
+const LOCK_ARGS_INVALID: i8 = 5;
+const DEX_TOTAL_VALUE_NOT_MATCH: i8 = 7;
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum DexError {
+    NoError,
+    LockArgsInvalid,
+    DexTotalValueNotMatch,
+}
+
+fn create_test_context(error: DexError) -> (Context, TransactionView) {
+    // deploy contract
+    let mut context = Context::default();
+    let dex_bin: Bytes = Loader::default().load_binary("dex-lock");
+    let dex_out_point = context.deploy_cell(dex_bin);
+    let dex_dep = CellDep::new_builder()
+        .out_point(dex_out_point.clone())
+        .build();
+
+    let always_success_code_hash = blake2b_256(ALWAYS_SUCCESS.clone());
+    let always_success_out_point = context.deploy_cell(ALWAYS_SUCCESS.clone());
+    let always_success_dep = CellDep::new_builder()
+        .out_point(always_success_out_point.clone())
+        .build();
+
+    let mut rng = thread_rng();
+    let owner_lock = context
+        .build_script(
+            &always_success_out_point,
+            rng.gen::<[u8; 20]>().to_vec().into(),
+        )
+        .expect("script");
+
+    let dex_args1 = DexArgs {
+        owner_lock:     owner_lock.clone(),
+        setup:          0u8,
+        total_value:    1234_5678_0000u128,
+        receiver_lock:  None,
+        unit_type_hash: None,
+    };
+    let dex_lock_script1 = context
+        .build_script(&dex_out_point, dex_args1.to_vec().into())
+        .expect("script");
+
+    let dex_args2 = DexArgs {
+        owner_lock:     owner_lock.clone(),
+        setup:          0u8,
+        total_value:    9_8765_0000_1234u128,
+        receiver_lock:  None,
+        unit_type_hash: None,
+    };
+    let mut dex_args2_vec = dex_args2.to_vec();
+    if error == DexError::LockArgsInvalid {
+        dex_args2_vec.reverse();
+    }
+    let dex_lock_script2 = context
+        .build_script(&dex_out_point, dex_args2_vec.into())
+        .expect("script");
+
+    let asset_type = ScriptBuilder::default()
+        .code_hash(Byte32::from_slice(&always_success_code_hash).unwrap())
+        .hash_type(Byte::from(2u8))
+        .build();
+
+    let asset_amount1 = Bytes::try_from(1000_0000_0000u128.to_le_bytes().to_vec()).unwrap();
+    let input_out_point1 = context.create_cell(
+        CellOutput::new_builder()
+            .capacity(300_0000_0000u64.pack())
+            .lock(dex_lock_script1)
+            .type_(Some(asset_type.clone()).pack())
+            .build(),
+        asset_amount1,
+    );
+    let asset_amount2 = Bytes::try_from(3456_0000_0000u128.to_le_bytes().to_vec()).unwrap();
+    let input_out_point2 = context.create_cell(
+        CellOutput::new_builder()
+            .capacity(240_0000_0000u64.pack())
+            .lock(dex_lock_script2)
+            .type_(Some(asset_type.clone()).pack())
+            .build(),
+        asset_amount2,
+    );
+    let input_out_point3 = context.create_cell(
+        CellOutput::new_builder()
+            .capacity(100_0000_0000u64.pack())
+            .lock(owner_lock.clone())
+            .build(),
+        Bytes::new(),
+    );
+
+    let mut inputs = vec![
+        CellInput::new_builder()
+            .previous_output(input_out_point1)
+            .build(),
+        CellInput::new_builder()
+            .previous_output(input_out_point2)
+            .build(),
+    ];
+    if error != DexError::DexTotalValueNotMatch {
+        inputs.push(
+            CellInput::new_builder()
+                .previous_output(input_out_point3)
+                .build(),
+        )
+    }
+
+    let output_asset_amount = Bytes::try_from(
+        (1000_0000_0000u128 + 3456_0000_0000u128)
+            .to_le_bytes()
+            .to_vec(),
+    )
+    .unwrap();
+    let outputs = vec![
+        CellOutput::new_builder()
+            .capacity(240_0000_0000u64.pack())
+            .lock(owner_lock.clone())
+            .type_(Some(asset_type).pack())
+            .build(),
+        CellOutput::new_builder()
+            .capacity(400_0000_0000u64.pack())
+            .lock(owner_lock)
+            .build(),
+    ];
+
+    let outputs_data = vec![output_asset_amount, Bytes::new()];
+
+    let mut witnesses = vec![];
+    for _ in 0..inputs.len() {
+        witnesses.push(Bytes::new())
+    }
+
+    let cell_deps = vec![always_success_dep, dex_dep];
+    // build transaction
+    let tx = TransactionBuilder::default()
+        .inputs(inputs)
+        .outputs(outputs)
+        .outputs_data(outputs_data.pack())
+        .cell_deps(cell_deps)
+        .witnesses(witnesses.pack())
+        .build();
+    let tx = context.complete_tx(tx);
+
+    // sign
+    (context, tx)
+}
+
+#[test]
+fn test_dex_cancel_order_success() {
+    let (context, tx) = create_test_context(DexError::NoError);
+    // run
+    let cycles = context
+        .verify_tx(&tx, MAX_CYCLES)
+        .expect("pass verification");
+    println!("consume cycles: {}", cycles);
+}
+
+#[test]
+fn test_dex_cancel_order_lock_args_error() {
+    let (context, tx) = create_test_context(DexError::LockArgsInvalid);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, LOCK_ARGS_INVALID);
+}
+
+#[test]
+fn test_dex_cancel_order_owner_lock_not_match_error() {
+    let (context, tx) = create_test_context(DexError::DexTotalValueNotMatch);
+    // run
+    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
+    assert_script_error(err, DEX_TOTAL_VALUE_NOT_MATCH);
+}
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 009754f..6172043 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -5,6 +5,8 @@ use std::fs;
 use std::path::PathBuf;
 use std::str::FromStr;
 
+#[cfg(test)]
+mod cancel_tests;
 mod helper;
 #[cfg(test)]
 mod taker_tests;