diff --git a/src/seutil.rs b/src/seutil.rs
index a8469d8..0d629df 100644
--- a/src/seutil.rs
+++ b/src/seutil.rs
@@ -1,10 +1,11 @@
 use base64::engine::general_purpose::STANDARD;
 use base64::Engine;
 use rust_util::XResult;
-use swift_secure_enclave_tool_rs::KeyPurpose;
+use se_tool::KeyPurpose;
+use swift_secure_enclave_tool_rs as se_tool;
 
 pub fn is_support_se() -> bool {
-    swift_secure_enclave_tool_rs::is_secure_enclave_supported().unwrap_or(false)
+    se_tool::is_secure_enclave_supported().unwrap_or(false)
 }
 
 pub fn generate_secure_enclave_p256_keypair(
@@ -12,9 +13,9 @@ pub fn generate_secure_enclave_p256_keypair(
     require_bio: bool,
 ) -> XResult<(Vec<u8>, Vec<u8>, String)> {
     let key_material = if sign {
-        swift_secure_enclave_tool_rs::generate_keypair(KeyPurpose::Signing, require_bio)?
+        se_tool::generate_keypair(KeyPurpose::Signing, require_bio)?
     } else {
-        swift_secure_enclave_tool_rs::generate_keypair(KeyPurpose::KeyAgreement, require_bio)?
+        se_tool::generate_keypair(KeyPurpose::KeyAgreement, require_bio)?
     };
     Ok((
         key_material.public_key_point,
@@ -29,15 +30,9 @@ pub fn recover_secure_enclave_p256_public_key(
 ) -> XResult<(Vec<u8>, Vec<u8>, String)> {
     let private_key_representation = STANDARD.decode(private_key)?;
     let key_material = if sign {
-        swift_secure_enclave_tool_rs::recover_keypair(
-            KeyPurpose::Signing,
-            &private_key_representation,
-        )
+        se_tool::recover_keypair(KeyPurpose::Signing, &private_key_representation)
     } else {
-        swift_secure_enclave_tool_rs::recover_keypair(
-            KeyPurpose::KeyAgreement,
-            &private_key_representation,
-        )
+        se_tool::recover_keypair(KeyPurpose::KeyAgreement, &private_key_representation)
     }?;
     Ok((
         key_material.public_key_point,
@@ -51,16 +46,13 @@ pub fn secure_enclave_p256_dh(
     ephemeral_public_key_bytes: &[u8],
 ) -> XResult<Vec<u8>> {
     let private_key_representation = STANDARD.decode(private_key)?;
-    let shared_secret = swift_secure_enclave_tool_rs::private_key_ecdh(
-        &private_key_representation,
-        ephemeral_public_key_bytes,
-    )?;
+    let shared_secret =
+        se_tool::private_key_ecdh(&private_key_representation, ephemeral_public_key_bytes)?;
     Ok(shared_secret)
 }
 
 pub fn secure_enclave_p256_sign(private_key: &str, content: &[u8]) -> XResult<Vec<u8>> {
     let private_key_representation = STANDARD.decode(private_key)?;
-    let signature =
-        swift_secure_enclave_tool_rs::private_key_sign(&private_key_representation, content)?;
+    let signature = se_tool::private_key_sign(&private_key_representation, content)?;
     Ok(signature)
 }