diff --git a/core/embed/extmod/modtrezorcrypto/modtrezorcrypto-secp256k1.h b/core/embed/extmod/modtrezorcrypto/modtrezorcrypto-secp256k1.h
index 46534e51b..2c1b17fc3 100644
--- a/core/embed/extmod/modtrezorcrypto/modtrezorcrypto-secp256k1.h
+++ b/core/embed/extmod/modtrezorcrypto/modtrezorcrypto-secp256k1.h
@@ -22,10 +22,6 @@
 #include "vendor/trezor-crypto/ecdsa.h"
 #include "vendor/trezor-crypto/secp256k1.h"
 
-#ifdef USE_SECP256K1_ZKP_ECDSA
-#include "zkp_ecdsa.h"
-#endif
-
 /// package: trezorcrypto.secp256k1
 
 /// def generate_secret() -> bytes:
@@ -75,23 +71,12 @@ STATIC mp_obj_t mod_trezorcrypto_secp256k1_publickey(size_t n_args,
   bool compressed = n_args < 2 || args[1] == mp_const_true;
   if (compressed) {
     vstr_init_len(&pk, 33);
-#ifdef USE_SECP256K1_ZKP_ECDSA
-    ret = zkp_ecdsa_get_public_key33(&secp256k1, (const uint8_t *)sk.buf,
-                                     (uint8_t *)pk.buf);
-#else
     ret = ecdsa_get_public_key33(&secp256k1, (const uint8_t *)sk.buf,
                                  (uint8_t *)pk.buf);
-#endif
-
   } else {
     vstr_init_len(&pk, 65);
-#ifdef USE_SECP256K1_ZKP_ECDSA
-    ret = zkp_ecdsa_get_public_key65(&secp256k1, (const uint8_t *)sk.buf,
-                                     (uint8_t *)pk.buf);
-#else
     ret = ecdsa_get_public_key65(&secp256k1, (const uint8_t *)sk.buf,
                                  (uint8_t *)pk.buf);
-#endif
   }
   if (0 != ret) {
     vstr_clear(&pk);
@@ -166,20 +151,9 @@ STATIC mp_obj_t mod_trezorcrypto_secp256k1_sign(size_t n_args,
   vstr_t sig = {0};
   vstr_init_len(&sig, 65);
   uint8_t pby = 0;
-  int ret = 0;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  if (!is_canonical) {
-    ret = zkp_ecdsa_sign_digest(&secp256k1, (const uint8_t *)sk.buf,
-                                (const uint8_t *)dig.buf,
-                                (uint8_t *)sig.buf + 1, &pby, is_canonical);
-  } else
-#endif
-  {
-    ret = ecdsa_sign_digest(&secp256k1, (const uint8_t *)sk.buf,
-                            (const uint8_t *)dig.buf, (uint8_t *)sig.buf + 1,
-                            &pby, is_canonical);
-  }
-  if (0 != ret) {
+  if (0 != ecdsa_sign_digest(&secp256k1, (const uint8_t *)sk.buf,
+                             (const uint8_t *)dig.buf, (uint8_t *)sig.buf + 1,
+                             &pby, is_canonical)) {
     vstr_clear(&sig);
     mp_raise_ValueError("Signing failed");
   }
@@ -212,16 +186,9 @@ STATIC mp_obj_t mod_trezorcrypto_secp256k1_verify(mp_obj_t public_key,
   if (dig.len != 32) {
     return mp_const_false;
   }
-  int ret = 0;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  ret = zkp_ecdsa_verify_digest(&secp256k1, (const uint8_t *)pk.buf,
+  int ret = ecdsa_verify_digest(&secp256k1, (const uint8_t *)pk.buf,
                                 (const uint8_t *)sig.buf + offset,
                                 (const uint8_t *)dig.buf);
-#else
-  ret = ecdsa_verify_digest(&secp256k1, (const uint8_t *)pk.buf,
-                            (const uint8_t *)sig.buf + offset,
-                            (const uint8_t *)dig.buf);
-#endif
   return mp_obj_new_bool(ret == 0);
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_3(mod_trezorcrypto_secp256k1_verify_obj,
@@ -251,17 +218,9 @@ STATIC mp_obj_t mod_trezorcrypto_secp256k1_verify_recover(mp_obj_t signature,
   recid &= 3;
   vstr_t pk = {0};
   vstr_init_len(&pk, 65);
-  int ret = 0;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  ret = zkp_ecdsa_recover_pub_from_sig(&secp256k1, (uint8_t *)pk.buf,
-                                       (const uint8_t *)sig.buf + 1,
-                                       (const uint8_t *)dig.buf, recid);
-#else
-  ret = ecdsa_recover_pub_from_sig(&secp256k1, (uint8_t *)pk.buf,
-                                   (const uint8_t *)sig.buf + 1,
-                                   (const uint8_t *)dig.buf, recid);
-#endif
-  if (ret == 0) {
+  if (ecdsa_recover_pub_from_sig(&secp256k1, (uint8_t *)pk.buf,
+                                 (const uint8_t *)sig.buf + 1,
+                                 (const uint8_t *)dig.buf, recid) == 0) {
     if (compressed) {
       pk.buf[0] = 0x02 | (pk.buf[64] & 1);
       pk.len = 33;
diff --git a/crypto/ecdsa.c b/crypto/ecdsa.c
index f9ff33faf..33ab45d6f 100644
--- a/crypto/ecdsa.c
+++ b/crypto/ecdsa.c
@@ -36,6 +36,9 @@
 #include "rand.h"
 #include "rfc6979.h"
 #include "secp256k1.h"
+#ifdef USE_SECP256K1_ZKP_ECDSA
+#include "zkp_ecdsa.h"
+#endif
 
 // Set cp2 = cp1
 void point_copy(const curve_point *cp1, curve_point *cp2) { *cp2 = *cp1; }
@@ -676,9 +679,9 @@ int ecdsa_sign(const ecdsa_curve *curve, HasherType hasher_sign,
 // digest is 32 bytes of digest
 // is_canonical is an optional function that checks if the signature
 // conforms to additional coin-specific rules.
-int ecdsa_sign_digest(const ecdsa_curve *curve, const uint8_t *priv_key,
-                      const uint8_t *digest, uint8_t *sig, uint8_t *pby,
-                      int (*is_canonical)(uint8_t by, uint8_t sig[64])) {
+int tc_ecdsa_sign_digest(const ecdsa_curve *curve, const uint8_t *priv_key,
+                         const uint8_t *digest, uint8_t *sig, uint8_t *pby,
+                         int (*is_canonical)(uint8_t by, uint8_t sig[64])) {
   int i = 0;
   curve_point R = {0};
   bignum256 k = {0}, z = {0}, randk = {0};
@@ -782,8 +785,8 @@ int ecdsa_sign_digest(const ecdsa_curve *curve, const uint8_t *priv_key,
 }
 
 // returns 0 on success
-int ecdsa_get_public_key33(const ecdsa_curve *curve, const uint8_t *priv_key,
-                           uint8_t *pub_key) {
+int tc_ecdsa_get_public_key33(const ecdsa_curve *curve, const uint8_t *priv_key,
+                              uint8_t *pub_key) {
   curve_point R = {0};
   bignum256 k = {0};
 
@@ -807,8 +810,8 @@ int ecdsa_get_public_key33(const ecdsa_curve *curve, const uint8_t *priv_key,
 }
 
 // returns 0 on success
-int ecdsa_get_public_key65(const ecdsa_curve *curve, const uint8_t *priv_key,
-                           uint8_t *pub_key) {
+int tc_ecdsa_get_public_key65(const ecdsa_curve *curve, const uint8_t *priv_key,
+                              uint8_t *pub_key) {
   curve_point R = {0};
   bignum256 k = {0};
 
@@ -1019,9 +1022,9 @@ int ecdsa_verify(const ecdsa_curve *curve, HasherType hasher_sign,
 
 // Compute public key from signature and recovery id.
 // returns 0 if the key is successfully recovered
-int ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
-                               const uint8_t *sig, const uint8_t *digest,
-                               int recid) {
+int tc_ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
+                                  const uint8_t *sig, const uint8_t *digest,
+                                  int recid) {
   bignum256 r = {0}, s = {0}, e = {0};
   curve_point cp = {0}, cp2 = {0};
 
@@ -1076,8 +1079,8 @@ int ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
 }
 
 // returns 0 if verification succeeded
-int ecdsa_verify_digest(const ecdsa_curve *curve, const uint8_t *pub_key,
-                        const uint8_t *sig, const uint8_t *digest) {
+int tc_ecdsa_verify_digest(const ecdsa_curve *curve, const uint8_t *pub_key,
+                           const uint8_t *sig, const uint8_t *digest) {
   curve_point pub = {0}, res = {0};
   bignum256 r = {0}, s = {0}, z = {0};
   int result = 0;
@@ -1249,3 +1252,56 @@ int ecdsa_sig_from_der(const uint8_t *der, size_t der_len, uint8_t sig[64]) {
 
   return 0;
 }
+
+int ecdsa_get_public_key33(const ecdsa_curve *curve, const uint8_t *priv_key,
+                           uint8_t *pub_key) {
+#ifdef USE_SECP256K1_ZKP_ECDSA
+  if (curve == &secp256k1) {
+    return zkp_ecdsa_get_public_key33(curve, priv_key, pub_key);
+  }
+#endif
+  return tc_ecdsa_get_public_key33(curve, priv_key, pub_key);
+}
+
+int ecdsa_get_public_key65(const ecdsa_curve *curve, const uint8_t *priv_key,
+                           uint8_t *pub_key) {
+#ifdef USE_SECP256K1_ZKP_ECDSA
+  if (curve == &secp256k1) {
+    return zkp_ecdsa_get_public_key65(curve, priv_key, pub_key);
+  }
+#endif
+  return tc_ecdsa_get_public_key65(curve, priv_key, pub_key);
+}
+
+int ecdsa_sign_digest(const ecdsa_curve *curve, const uint8_t *priv_key,
+                      const uint8_t *digest, uint8_t *sig, uint8_t *pby,
+                      int (*is_canonical)(uint8_t by, uint8_t sig[64])) {
+#ifdef USE_SECP256K1_ZKP_ECDSA
+  if (curve == &secp256k1 && is_canonical == NULL) {
+    return zkp_ecdsa_sign_digest(curve, priv_key, digest, sig, pby,
+                                 is_canonical);
+  }
+#endif
+  return tc_ecdsa_sign_digest(curve, priv_key, digest, sig, pby, is_canonical);
+}
+
+int ecdsa_verify_digest(const ecdsa_curve *curve, const uint8_t *pub_key,
+                        const uint8_t *sig, const uint8_t *digest) {
+#ifdef USE_SECP256K1_ZKP_ECDSA
+  if (curve == &secp256k1) {
+    return zkp_ecdsa_verify_digest(curve, pub_key, sig, digest);
+  }
+#endif
+  return tc_ecdsa_verify_digest(curve, pub_key, sig, digest);
+}
+
+int ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
+                               const uint8_t *sig, const uint8_t *digest,
+                               int recid) {
+#ifdef USE_SECP256K1_ZKP_ECDSA
+  if (curve == &secp256k1) {
+    return zkp_ecdsa_recover_pub_from_sig(curve, pub_key, sig, digest, recid);
+  }
+#endif
+  return tc_ecdsa_recover_pub_from_sig(curve, pub_key, sig, digest, recid);
+}
diff --git a/crypto/ecdsa.h b/crypto/ecdsa.h
index 7b951d236..ecd69ea73 100644
--- a/crypto/ecdsa.h
+++ b/crypto/ecdsa.h
@@ -125,4 +125,18 @@ int ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
 int ecdsa_sig_to_der(const uint8_t *sig, uint8_t *der);
 int ecdsa_sig_from_der(const uint8_t *der, size_t der_len, uint8_t sig[64]);
 
+// trezor-crypto native implementations
+int tc_ecdsa_get_public_key33(const ecdsa_curve *curve, const uint8_t *priv_key,
+                              uint8_t *pub_key);
+int tc_ecdsa_get_public_key65(const ecdsa_curve *curve, const uint8_t *priv_key,
+                              uint8_t *pub_key);
+int tc_ecdsa_sign_digest(const ecdsa_curve *curve, const uint8_t *priv_key,
+                         const uint8_t *digest, uint8_t *sig, uint8_t *pby,
+                         int (*is_canonical)(uint8_t by, uint8_t sig[64]));
+int tc_ecdsa_verify_digest(const ecdsa_curve *curve, const uint8_t *pub_key,
+                           const uint8_t *sig, const uint8_t *digest);
+int tc_ecdsa_recover_pub_from_sig(const ecdsa_curve *curve, uint8_t *pub_key,
+                                  const uint8_t *sig, const uint8_t *digest,
+                                  int recid);
+
 #endif
diff --git a/crypto/fuzzer/fuzzer.c b/crypto/fuzzer/fuzzer.c
index 767eea4f9..94b1af0a3 100644
--- a/crypto/fuzzer/fuzzer.c
+++ b/crypto/fuzzer/fuzzer.c
@@ -540,7 +540,7 @@ int fuzz_ecdsa_sign_digest_functions(void) {
   int res = 0;
 
   // TODO idea: optionally set a function for is_canonical() callback
-  int res1 = ecdsa_sign_digest(curve, priv_key, digest, sig1, &pby1, NULL);
+  int res1 = tc_ecdsa_sign_digest(curve, priv_key, digest, sig1, &pby1, NULL);
 
   // the zkp function variant is only defined for a specific curve
   if (curve == &secp256k1) {
@@ -561,13 +561,13 @@ int fuzz_ecdsa_sign_digest_functions(void) {
   // successful signing
   if (res1 == 0) {
     uint8_t pub_key[33] = {0};
-    res = ecdsa_get_public_key33(curve, priv_key, pub_key);
+    res = tc_ecdsa_get_public_key33(curve, priv_key, pub_key);
     if (res != 0) {
       // pubkey derivation did not succeed
       crash();
     }
 
-    res = ecdsa_verify_digest(curve, pub_key, sig1, digest);
+    res = tc_ecdsa_verify_digest(curve, pub_key, sig1, digest);
     if (res != 0) {
       // verification did not succeed
       crash();
@@ -599,8 +599,9 @@ int fuzz_ecdsa_verify_digest_functions(void) {
     curve = &nist256p1;
   }
 
-  int res1 = ecdsa_verify_digest(curve, (const uint8_t *)&pub_key,
-                                 (const uint8_t *)&sig, (const uint8_t *)&hash);
+  int res1 =
+      tc_ecdsa_verify_digest(curve, (const uint8_t *)&pub_key,
+                             (const uint8_t *)&sig, (const uint8_t *)&hash);
   if (res1 == 0) {
     // See if the fuzzer ever manages to get find a correct verification
     // intentionally trigger a crash to make this case observable
@@ -1021,9 +1022,9 @@ int fuzz_ecdsa_get_public_key_functions(void) {
   }
   memcpy(privkey, fuzzer_input(sizeof(privkey)), sizeof(privkey));
 
-  int res_33_1 = ecdsa_get_public_key33(curve, privkey, pubkey33_1);
+  int res_33_1 = tc_ecdsa_get_public_key33(curve, privkey, pubkey33_1);
   int res_33_2 = zkp_ecdsa_get_public_key33(curve, privkey, pubkey33_2);
-  int res_65_1 = ecdsa_get_public_key65(curve, privkey, pubkey65_1);
+  int res_65_1 = tc_ecdsa_get_public_key65(curve, privkey, pubkey65_1);
   int res_65_2 = zkp_ecdsa_get_public_key65(curve, privkey, pubkey65_2);
 
   // the function pairs have different return error codes for the same input
@@ -1070,7 +1071,7 @@ int fuzz_ecdsa_recover_pub_from_sig_functions(void) {
   recid = recid & 0x03;
 
   int res1 = zkp_ecdsa_recover_pub_from_sig(curve, pubkey1, sig, digest, recid);
-  int res2 = ecdsa_recover_pub_from_sig(curve, pubkey2, sig, digest, recid);
+  int res2 = tc_ecdsa_recover_pub_from_sig(curve, pubkey2, sig, digest, recid);
 
   uint8_t zero_pubkey[65] = {0};
   zero_pubkey[0] = 0x04;
diff --git a/crypto/tests/test_check.c b/crypto/tests/test_check.c
index a95c35b66..822136406 100644
--- a/crypto/tests/test_check.c
+++ b/crypto/tests/test_check.c
@@ -3464,8 +3464,8 @@ static void test_ecdsa_get_public_key33_helper(int (*ecdsa_get_public_key33_fn)(
       33);
 }
 
-START_TEST(test_ecdsa_get_public_key33) {
-  test_ecdsa_get_public_key33_helper(ecdsa_get_public_key33);
+START_TEST(test_tc_ecdsa_get_public_key33) {
+  test_ecdsa_get_public_key33_helper(tc_ecdsa_get_public_key33);
 }
 END_TEST
 
@@ -3496,8 +3496,8 @@ static void test_ecdsa_get_public_key65_helper(int (*ecdsa_get_public_key65_fn)(
       65);
 }
 
-START_TEST(test_ecdsa_get_public_key65) {
-  test_ecdsa_get_public_key65_helper(ecdsa_get_public_key65);
+START_TEST(test_tc_ecdsa_get_public_key65) {
+  test_ecdsa_get_public_key65_helper(tc_ecdsa_get_public_key65);
 }
 END_TEST
 
@@ -3704,8 +3704,8 @@ static void test_ecdsa_recover_pub_from_sig_helper(int (
   ck_assert_int_eq(res, 1);
 }
 
-START_TEST(test_ecdsa_recover_pub_from_sig) {
-  test_ecdsa_recover_pub_from_sig_helper(ecdsa_recover_pub_from_sig);
+START_TEST(test_tc_ecdsa_recover_pub_from_sig) {
+  test_ecdsa_recover_pub_from_sig_helper(tc_ecdsa_recover_pub_from_sig);
 }
 END_TEST
 
@@ -3744,8 +3744,8 @@ static void test_ecdsa_verify_digest_helper(int (*ecdsa_verify_digest_fn)(
   ck_assert_int_eq(res, 0);
 }
 
-START_TEST(test_ecdsa_verify_digest) {
-  test_ecdsa_verify_digest_helper(ecdsa_verify_digest);
+START_TEST(test_tc_ecdsa_verify_digest) {
+  test_ecdsa_verify_digest_helper(tc_ecdsa_verify_digest);
 }
 END_TEST
 
@@ -3840,8 +3840,8 @@ static void test_ecdsa_sign_digest_deterministic_helper(
   }
 }
 
-START_TEST(test_ecdsa_sign_digest_deterministic) {
-  test_ecdsa_sign_digest_deterministic_helper(ecdsa_sign_digest);
+START_TEST(test_tc_ecdsa_sign_digest_deterministic) {
+  test_ecdsa_sign_digest_deterministic_helper(tc_ecdsa_sign_digest);
 }
 END_TEST
 
@@ -9501,16 +9501,16 @@ Suite *test_suite(void) {
   suite_add_tcase(s, tc);
 
   tc = tcase_create("ecdsa");
-  tcase_add_test(tc, test_ecdsa_get_public_key33);
-  tcase_add_test(tc, test_ecdsa_get_public_key65);
-  tcase_add_test(tc, test_ecdsa_recover_pub_from_sig);
-  tcase_add_test(tc, test_ecdsa_verify_digest);
+  tcase_add_test(tc, test_tc_ecdsa_get_public_key33);
+  tcase_add_test(tc, test_tc_ecdsa_get_public_key65);
+  tcase_add_test(tc, test_tc_ecdsa_recover_pub_from_sig);
+  tcase_add_test(tc, test_tc_ecdsa_verify_digest);
   tcase_add_test(tc, test_zkp_ecdsa_get_public_key33);
   tcase_add_test(tc, test_zkp_ecdsa_get_public_key65);
   tcase_add_test(tc, test_zkp_ecdsa_recover_pub_from_sig);
   tcase_add_test(tc, test_zkp_ecdsa_verify_digest);
 #if USE_RFC6979
-  tcase_add_test(tc, test_ecdsa_sign_digest_deterministic);
+  tcase_add_test(tc, test_tc_ecdsa_sign_digest_deterministic);
   tcase_add_test(tc, test_zkp_ecdsa_sign_digest_deterministic);
 #endif
   suite_add_tcase(s, tc);
diff --git a/crypto/tests/test_curves.py b/crypto/tests/test_curves.py
index ea945c66a..7bdbf928a 100755
--- a/crypto/tests/test_curves.py
+++ b/crypto/tests/test_curves.py
@@ -290,12 +290,12 @@ def sigdecode(sig, _):
     return map(bytes2num, [sig[:32], sig[32:]])
 
 
-def test_sign(curve, r):
+def test_sign_native(curve, r):
     priv = r.randbytes(32)
     digest = r.randbytes(32)
     sig = r.randbytes(64)
 
-    lib.ecdsa_sign_digest(curve.ptr, priv, digest, sig, c.c_void_p(0), c.c_void_p(0))
+    lib.tc_ecdsa_sign_digest(curve.ptr, priv, digest, sig, c.c_void_p(0), c.c_void_p(0))
 
     exp = bytes2num(priv)
     sk = ecdsa.SigningKey.from_secret_exponent(exp, curve, hashfunc=hashlib.sha256)
diff --git a/legacy/firmware/ethereum.c b/legacy/firmware/ethereum.c
index 0804410d8..1c2fb1eaa 100644
--- a/legacy/firmware/ethereum.c
+++ b/legacy/firmware/ethereum.c
@@ -36,9 +36,6 @@
 #include "sha3.h"
 #include "transaction.h"
 #include "util.h"
-#ifdef USE_SECP256K1_ZKP_ECDSA
-#include "zkp_ecdsa.h"
-#endif
 
 /* Maximum chain_id which returns the full signature_v (which must fit into an
 uint32). chain_ids larger than this will only return one bit and the caller must
@@ -952,15 +949,8 @@ int ethereum_message_verify(const EthereumVerifyMessage *msg) {
     return 2;
   }
 
-  int ret = 0;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  ret = zkp_ecdsa_recover_pub_from_sig(&secp256k1, pubkey, msg->signature.bytes,
-                                       hash, v);
-#else
-  ret = ecdsa_recover_pub_from_sig(&secp256k1, pubkey, msg->signature.bytes,
-                                   hash, v);
-#endif
-  if (ret != 0) {
+  if (ecdsa_recover_pub_from_sig(&secp256k1, pubkey, msg->signature.bytes, hash,
+                                 v) != 0) {
     return 2;
   }
 
diff --git a/legacy/firmware/signing.c b/legacy/firmware/signing.c
index 2d5bb663c..25398289d 100644
--- a/legacy/firmware/signing.c
+++ b/legacy/firmware/signing.c
@@ -31,9 +31,6 @@
 #include "secp256k1.h"
 #include "transaction.h"
 #include "zkp_bip340.h"
-#ifdef USE_SECP256K1_ZKP_ECDSA
-#include "zkp_ecdsa.h"
-#endif
 
 static uint32_t change_count;
 static const CoinInfo *coin;
@@ -2270,16 +2267,8 @@ static bool signing_verify_orig_nonlegacy_input(TxInputType *orig_input) {
       signing_hash_bip143(&orig_info, orig_input, hash);
     }
 
-#ifdef USE_SECP256K1_ZKP_ECDSA
-    if (coin->curve->params == &secp256k1) {
-      valid = zkp_ecdsa_verify_digest(coin->curve->params, node.public_key, sig,
-                                      hash) == 0;
-    } else
-#endif
-    {
-      valid = ecdsa_verify_digest(coin->curve->params, node.public_key, sig,
-                                  hash) == 0;
-    }
+    valid = ecdsa_verify_digest(coin->curve->params, node.public_key, sig,
+                                hash) == 0;
   }
 
   if (!valid) {
@@ -2299,17 +2288,8 @@ static bool signing_verify_orig_legacy_input(void) {
   uint8_t hash[32] = {0};
   tx_hash_final(&ti, hash, false);
 
-  bool valid = false;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  if (coin->curve->params == &secp256k1) {
-    valid = zkp_ecdsa_verify_digest(coin->curve->params, node.public_key, sig,
-                                    hash) == 0;
-  } else
-#endif
-  {
-    valid = ecdsa_verify_digest(coin->curve->params, node.public_key, sig,
-                                hash) == 0;
-  }
+  bool valid =
+      ecdsa_verify_digest(coin->curve->params, node.public_key, sig, hash) == 0;
 
   if (!valid) {
     fsm_sendFailure(FailureType_Failure_DataError, _("Invalid signature."));
@@ -2547,18 +2527,8 @@ static bool signing_sign_ecdsa(TxInputType *txinput, const uint8_t *private_key,
   resp.serialized.has_signature = true;
   resp.serialized.has_serialized_tx = true;
 
-  int ret = 0;
-#ifdef USE_SECP256K1_ZKP_ECDSA
-  if (coin->curve->params == &secp256k1) {
-    ret = zkp_ecdsa_sign_digest(coin->curve->params, private_key, hash, sig,
-                                NULL, NULL);
-  } else
-#endif
-  {
-    ret = ecdsa_sign_digest(coin->curve->params, private_key, hash, sig, NULL,
-                            NULL);
-  }
-  if (ret != 0) {
+  if (ecdsa_sign_digest(coin->curve->params, private_key, hash, sig, NULL,
+                        NULL) != 0) {
     fsm_sendFailure(FailureType_Failure_ProcessError, _("Signing failed"));
     signing_abort();
     return false;
diff --git a/tests/ui_tests/fixtures.json b/tests/ui_tests/fixtures.json
index 4a3fd0f77..93a0d3c23 100644
--- a/tests/ui_tests/fixtures.json
+++ b/tests/ui_tests/fixtures.json
@@ -501,7 +501,7 @@
 "T1_stellar-test_stellar.py::test_sign_tx[timebounds-0-1575234180]": "a92beafd4711e0768f9453c3cf7958882f4f3439d9e14ca1e69db617e00bd790",
 "T1_stellar-test_stellar.py::test_sign_tx[timebounds-461535181-0]": "da273d8bb839bc1f80ff5af65d4c7f4d67ccc5be41a0a5f7a24452f12f7975d7",
 "T1_stellar-test_stellar.py::test_sign_tx[timebounds-461535181-1575234180]": "1c8218b025efff40431aa5e468f33475360d40d99fbfe5f4fd8d4607f5857b53",
-"T1_test_autolock.py::test_apply_auto_lock_delay": "5f289c3212462aca47778a8253ab33eab7931b34aa7404f5893ac02f279cfafd",
+"T1_test_autolock.py::test_apply_auto_lock_delay": "f7bfdce7fa7579fe43beb0afd9b123114ea873f28da530abe3df8802570012bb",
 "T1_test_autolock.py::test_apply_auto_lock_delay_out_of_range[0]": "8c78ab77bce7753cd12e8085ca4da375c4882e8c3c8c9df212b2a39a3f9cba3c",
 "T1_test_autolock.py::test_apply_auto_lock_delay_out_of_range[1]": "8c78ab77bce7753cd12e8085ca4da375c4882e8c3c8c9df212b2a39a3f9cba3c",
 "T1_test_autolock.py::test_apply_auto_lock_delay_out_of_range[4194304]": "8c78ab77bce7753cd12e8085ca4da375c4882e8c3c8c9df212b2a39a3f9cba3c",
@@ -543,19 +543,19 @@
 "T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_invalid[1204]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_invalid[1234567891234567891234567891234-943f94d5": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_invalid[]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-"T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_mismatch": "a09967f995cdfec7877dd43c002ea29fb395dea21b5d5e42386634ba4a106541",
+"T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_mismatch": "e64e729d09f856e446c532f24fcb7127af04bee015c5f2636dbd30c7435b9c48",
 "T1_test_msg_change_wipe_code_t1.py::test_set_wipe_code_to_pin": "2e9a43e4c73ab5a4c013de17effb531bbc3f2eb4c2ef584717cbbb3b66a94e2a",
 "T1_test_msg_changepin_t1.py::test_change_mismatch": "8f9a0177ef2b66b43e6940c7820809dc1d135d9d410db1898a0e4cbbca5ceb0b",
-"T1_test_msg_changepin_t1.py::test_change_pin": "4b2218287d5f28d6147aff770b74c056a95703de3a69543b12dd3d9a6c3a45a4",
+"T1_test_msg_changepin_t1.py::test_change_pin": "8809c4ec33f71e5baa68387d22e2d8516cc645d4db26ab2653e58e0147cbab0a",
 "T1_test_msg_changepin_t1.py::test_enter_invalid[1204]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_changepin_t1.py::test_enter_invalid[123456789123456789123456789123456789123456789123451]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_changepin_t1.py::test_enter_invalid[]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-"T1_test_msg_changepin_t1.py::test_remove_pin": "11b3fc40c61c472426255e2719c987ec450fc2d6ac7c3291fc8f8acadcb78563",
+"T1_test_msg_changepin_t1.py::test_remove_pin": "bd74cf9520e364d895b59dfe766e53825be8178274fc222750326b4c603b8b3e",
 "T1_test_msg_changepin_t1.py::test_set_invalid[1204]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_changepin_t1.py::test_set_invalid[123456789123456789123456789123456789123456789123451]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_msg_changepin_t1.py::test_set_invalid[]": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-"T1_test_msg_changepin_t1.py::test_set_mismatch": "761aaf5f01b16879c37f5656f59d1056354506ec5925adfd0b662c08e7a29bcb",
-"T1_test_msg_changepin_t1.py::test_set_pin": "0609964befa185e008e1e027defa9076cdaa02d83912ec5dcdc1ee09f7c3c085",
+"T1_test_msg_changepin_t1.py::test_set_mismatch": "9ac8ffe75bd7a8b7cd56198b0112dda1cba925c1109acaa306f864b4b9e276ad",
+"T1_test_msg_changepin_t1.py::test_set_pin": "a1a9bb1a5035ff8277120ccdff9cdee1b8875fcaac2a2d279e5a54bfdc38fa81",
 "T1_test_msg_loaddevice.py::test_load_device_1": "0e92c294292142cbb286b613d40d2fdee8977f18285823ce896f40c2269a3ecd",
 "T1_test_msg_loaddevice.py::test_load_device_2": "f89f8fcecf250b76dcca3e52a5a678e14ca5eeae105fa59848db41ab514d6614",
 "T1_test_msg_loaddevice.py::test_load_device_utf": "9523984b9cd124422558fe14ae20aab35338f86f08756d11919db7b2d3b86781",
@@ -566,23 +566,23 @@
 "T1_test_pin.py::test_exponential_backoff_t1": "b8e1017505578b2ee34dd13c607d65a2a0d259878b04869dfb1be5b3622d58c7",
 "T1_test_pin.py::test_incorrect_pin_t1": "8c78ab77bce7753cd12e8085ca4da375c4882e8c3c8c9df212b2a39a3f9cba3c",
 "T1_test_pin.py::test_no_protection": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-"T1_test_protection_levels.py::test_apply_settings": "af9edc0f8ab95a119d48f8ba3dad120dd95459eb8ec01a7cc8e3e5d8cd615981",
-"T1_test_protection_levels.py::test_change_pin_t1": "b03b10c08880556b5b5b3909f9d55486b4b27079eb0b56ce339ca020521ab664",
-"T1_test_protection_levels.py::test_get_address": "5b7419ecda88e49d9a55af9e7c7dc6d96e5992e11515299c7794de6e2e834eef",
-"T1_test_protection_levels.py::test_get_entropy": "a858148a335093e46872966e6411cd1bf9d0899bba6a3c798d7535e01461273b",
-"T1_test_protection_levels.py::test_get_public_key": "5b7419ecda88e49d9a55af9e7c7dc6d96e5992e11515299c7794de6e2e834eef",
+"T1_test_protection_levels.py::test_apply_settings": "0f02ea5b45c4d7337ae59eedf0c91f42fae18f657ebe7f121ffb8160d532a25d",
+"T1_test_protection_levels.py::test_change_pin_t1": "f6e681d7987267465a082dbe914491004dd2eb517cb1cc8efb14650f5df5ceee",
+"T1_test_protection_levels.py::test_get_address": "33bc46d7179663c1b72d116b8c0dd1768e89d58c4154bb6a21e750fea83b90dd",
+"T1_test_protection_levels.py::test_get_entropy": "076d586a9a24e375f970cedc1b9f01a12e97b92bec04652cc5a86d7c50e7c552",
+"T1_test_protection_levels.py::test_get_public_key": "33bc46d7179663c1b72d116b8c0dd1768e89d58c4154bb6a21e750fea83b90dd",
 "T1_test_protection_levels.py::test_initialize": "3f4bd58ada8b2be88ceaf45b3653e940bd52f48eb42bd5ee43c0a8c7dd392139",
 "T1_test_protection_levels.py::test_passphrase_cached": "79a607736c6833a04561231c8db1df8cf6ac186715fc3798be9cc3456a588e24",
 "T1_test_protection_levels.py::test_ping": "de7fc40b2f35e82fa486f1b97ee3e34a96d0a67412537e8a0fddacc0b0b1649d",
 "T1_test_protection_levels.py::test_recovery_device": "9bcc413cf3e44af03f2dbb038c4df43bf503805447b71dd5713ab34335f9341b",
 "T1_test_protection_levels.py::test_reset_device": "b76ab8da407423d61c605a6c1a5851885ea0aa0fe81b23a7bdb6f9f39492aed0",
-"T1_test_protection_levels.py::test_sign_message": "c0ffb0307822ff7327b23e0e7db6a9396cacca93880afe8960d1b0469978a49d",
-"T1_test_protection_levels.py::test_signtx": "ccace7e0450a6f6e9c8ec0dcf1abad3e5fecbb7148ff2d5c7f9777939f5b1b5d",
-"T1_test_protection_levels.py::test_unlocked": "4c32aa18ecc83cd6c642784ff825246e09ed8bc4b17f23a6127dac7c8b36bccf",
+"T1_test_protection_levels.py::test_sign_message": "c2303075f8b908d6e990b5f00599a4eecfbf0d8725804a48a94a6c18e4b92e10",
+"T1_test_protection_levels.py::test_signtx": "5f23d8fcf46e9691d78147ecc95920976918e18d831366fbe970028d92418ebb",
+"T1_test_protection_levels.py::test_unlocked": "7ebd713447825d40e120916a78439aa4e3fc19ad9e54b4fe622f95a3e669fbd4",
 "T1_test_protection_levels.py::test_verify_message_t1": "d4f8be1019f13604e2ceec12e65a0eccc8825ed07072479b355dd30e2ea83219",
 "T1_test_protection_levels.py::test_wipe_device": "71f454265675d5884e5419569ea85cc5fcb579de2dae23630fc3c9877b7e00be",
 "T1_test_session.py::test_cannot_resume_ended_session": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-"T1_test_session.py::test_clear_session": "43e6ff906945515ce92fd3716265e26942370e59045da527cc36356540f5bde1",
+"T1_test_session.py::test_clear_session": "c3fb7fced363b08b233802db7145a6a69045518265c02c7cd46342d255c7622a",
 "T1_test_session.py::test_end_session": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_session.py::test_end_session_only_current": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
 "T1_test_session.py::test_session_recycling": "d27ed7ff7933fe20c1c40b1d2774f855672b3b5c65e5f11a23f27f6c645820ae",
@@ -1514,7 +1514,7 @@
 "TT_stellar-test_stellar.py::test_sign_tx[timebounds-0-1575234180]": "5a2e48e82752f1b2b9e45518151e035821c281a88994f389c6feb54665042e43",
 "TT_stellar-test_stellar.py::test_sign_tx[timebounds-461535181-0]": "09c6860d1d2c8ad9de827da1e8006026bb37816122da461a8d31f8c400ba91de",
 "TT_stellar-test_stellar.py::test_sign_tx[timebounds-461535181-1575234180]": "b2015b9e0f9ff60e2ea4fca2942e97b70a320386c2043fb36acde4a830272098",
-"TT_test_autolock.py::test_apply_auto_lock_delay": "f57f41bb9d52cc411add20488a20412728a1fc85c4c384e3cd3bf6f506e9bff0",
+"TT_test_autolock.py::test_apply_auto_lock_delay": "1c2f9d06e5f8d5cd0a149529bf193c31bab74a2ee1d211f936841c4c2c07badc",
 "TT_test_autolock.py::test_apply_auto_lock_delay_out_of_range[0]": "d81ff1a197803cfda9180cad05dad5c1912a064da957d036c1311fa3eeef4b70",
 "TT_test_autolock.py::test_apply_auto_lock_delay_out_of_range[1]": "d81ff1a197803cfda9180cad05dad5c1912a064da957d036c1311fa3eeef4b70",
 "TT_test_autolock.py::test_apply_auto_lock_delay_out_of_range[4194304]": "d81ff1a197803cfda9180cad05dad5c1912a064da957d036c1311fa3eeef4b70",
@@ -1559,15 +1559,15 @@
 "TT_test_msg_backup_device.py::test_no_backup_fails": "a489388c56078b4aa243d991b898b196a5c4b05573c526db06eeb11d41e98ec8",
 "TT_test_msg_backup_device.py::test_no_backup_show_entropy_fails": "836598efda5b456ccbee7835e31892bfb5a8b9d9e42948982f444e10b9b8e55a",
 "TT_test_msg_change_wipe_code_t2.py::test_set_pin_to_wipe_code": "fc83a78c24524bba5b7270b2d85e1ce788e4b200ac403b8f337cd32ef1008ed0",
-"TT_test_msg_change_wipe_code_t2.py::test_set_remove_wipe_code": "82aae9ec41d7a6bc2c53d066fc9773c833c3280590e8e13a990da4e9ba2367e0",
+"TT_test_msg_change_wipe_code_t2.py::test_set_remove_wipe_code": "722f638b95ce52ab0b1a6aa720ca277941fe84f9b40dbca2fe1faebb75872b99",
 "TT_test_msg_change_wipe_code_t2.py::test_set_wipe_code_mismatch": "a1a84ba5b6650fbada7de3e9b41d1273ef84bc2d0ea11377f08c05ad3d1c7169",
-"TT_test_msg_change_wipe_code_t2.py::test_set_wipe_code_to_pin": "9f91401e960174f79129bf7ac2e950203b9f2dcb381e0c7146fa1460c1bae678",
-"TT_test_msg_changepin_t2.py::test_change_failed": "b91f0af6e6148ff77b449e22e52523a462da819f5fca6b34b1bce8f50193f57d",
-"TT_test_msg_changepin_t2.py::test_change_invalid_current": "a8f2c71ef0605fb1f4f941d0c9bcc8bacefb84e88017a230c5b1ac67e8bc56fb",
-"TT_test_msg_changepin_t2.py::test_change_pin": "35b519f22ca2e65ad376efb5d570e68e610c64a6a137500d649a1fa6f05fdacf",
-"TT_test_msg_changepin_t2.py::test_remove_pin": "f46ea1ceaf07d2a47da2e89ceb9553b618ceb20aea004cf51a8f7df0bc78a453",
-"TT_test_msg_changepin_t2.py::test_set_failed": "36ae4d29086ee37c00aa038beee7112addc8da28c89110b069074e4b18a2de0d",
-"TT_test_msg_changepin_t2.py::test_set_pin": "f5786e0636f1fc51055e6e89cd8f7a5973de53a00e9594b97358ade61565a2b6",
+"TT_test_msg_change_wipe_code_t2.py::test_set_wipe_code_to_pin": "47ca44d7c30393ad094f846a67c2b09b9c23f6628cb142626187d65dfeb559e0",
+"TT_test_msg_changepin_t2.py::test_change_failed": "9a4f8c31f76edbfc102cce1314c99200c2025a5d921ca4f5ac66fc0c81344c47",
+"TT_test_msg_changepin_t2.py::test_change_invalid_current": "ea36b1ba6e88846933e9e34ad79d53c22036d2dd9fe64090147eb56f38fc8b8d",
+"TT_test_msg_changepin_t2.py::test_change_pin": "33b134342558a7df2e1d0cb6000bab100edd29e3e6e3d898cea972cfdf0b9830",
+"TT_test_msg_changepin_t2.py::test_remove_pin": "85239abbfd066c746e6ea7857af19d81e31bffdb1624e5109f434fdf0de6e1f7",
+"TT_test_msg_changepin_t2.py::test_set_failed": "e262d179b46d1e06efa5af75c95593cdd7e4eba074c907d46887808cb782df0e",
+"TT_test_msg_changepin_t2.py::test_set_pin": "285d0b1f927d7b2696ff8b1267974b3643302710d2408ff5a5649dbd6a2f02ba",
 "TT_test_msg_loaddevice.py::test_load_device_1": "ef73c09785df13124c3ebda99df038bbec0829f9474a923e152a647b39d5e47b",
 "TT_test_msg_loaddevice.py::test_load_device_2": "6a6717bbf58b0c2922dbbfc5e463c3ddc0db74a321d2fc2925da63bc20cba824",
 "TT_test_msg_loaddevice.py::test_load_device_slip39_advanced": "ef73c09785df13124c3ebda99df038bbec0829f9474a923e152a647b39d5e47b",
@@ -1587,26 +1587,26 @@
 "TT_test_pin.py::test_exponential_backoff_t2": "d4e7ed263d72c37c6f6d05c2e4aa4d8245267594511df704efe8a32f3c5c30ca",
 "TT_test_pin.py::test_incorrect_pin_t2": "3d549b537340e13140cd77f362f323ca116a79e58fb0784d69aadad7b5c13063",
 "TT_test_pin.py::test_no_protection": "c09de07fbbf1e047442180e2facb5482d06a1a428891b875b7dd93c9e4704ae1",
-"TT_test_protection_levels.py::test_apply_settings": "2451a804df4a867fef29adf4b71445352a3bface95a797f65bb87cf58c1ef34f",
-"TT_test_protection_levels.py::test_change_pin_t2": "d414bdebe6ea6b0f754aec1cdde61133b87fd27cf791ab1bdfdb61866a400d6c",
-"TT_test_protection_levels.py::test_get_address": "f0ac110de788b3112e04dc2ef131fca011a8dea1c309df37adeb23066729e273",
-"TT_test_protection_levels.py::test_get_entropy": "539ac09590d3252f0ccb2eb836c703a16be5a219c8bd46add57be8319a336ae9",
-"TT_test_protection_levels.py::test_get_public_key": "f0ac110de788b3112e04dc2ef131fca011a8dea1c309df37adeb23066729e273",
+"TT_test_protection_levels.py::test_apply_settings": "c45393e70f5b55c24d194a138cd5a7c58bc5d1cda3da94da18464dfc247f6816",
+"TT_test_protection_levels.py::test_change_pin_t2": "1d1e20a28d4ea0e2d728cd493cf2cbfa50c9fcc80dee86f6c96be2dd8335ea2b",
+"TT_test_protection_levels.py::test_get_address": "06bc9c33a944c5a3cc4ba35fb256641d44c3e71f7232b430c0ea2065ce636879",
+"TT_test_protection_levels.py::test_get_entropy": "6626a1633d2edb619a714c53d07d13d2b1c9353fc40d689e7bf6231bf33eb8aa",
+"TT_test_protection_levels.py::test_get_public_key": "06bc9c33a944c5a3cc4ba35fb256641d44c3e71f7232b430c0ea2065ce636879",
 "TT_test_protection_levels.py::test_initialize": "59e518cba8589979f0af46e2acb211d37c96312f1d1a63a899d138ebb2f3ca29",
 "TT_test_protection_levels.py::test_passphrase_cached": "7fe34cc300a6f3547eaf72ab4339b758469f1e2722244d2a14d06e55ab1a3716",
 "TT_test_protection_levels.py::test_passphrase_reporting[False]": "233f8978b159ec8fb4092599d63f001c8059222ca14a9e84d185560d3c32ce24",
 "TT_test_protection_levels.py::test_passphrase_reporting[True]": "d9e9bdb39d15d6737ed6234f16c36bb7ad95ca54067ff8f10cffccaa3caa96cb",
 "TT_test_protection_levels.py::test_ping": "5551c263e8e09c8ae683f4dec3dd9d7ecc05ebbd3f2556604b27479c8f1fbc82",
-"TT_test_protection_levels.py::test_sign_message": "045d2faee841a79441683a6fdc912c3c69ecc0289b6c9801580942d47af7f0de",
-"TT_test_protection_levels.py::test_signtx": "c939186b66fd7308ac21f12149cebb240c6697fff9df3187b8341660bf50019c",
-"TT_test_protection_levels.py::test_unlocked": "f2be4c8c13c6a201770966438ffa9bcfe0eb031683920f93a55fa92921a28b51",
-"TT_test_protection_levels.py::test_verify_message_t2": "0cf43552a15684fbf506cd56871ca07795f62ec5f57176705aa968c9f97ef3d8",
+"TT_test_protection_levels.py::test_sign_message": "fe0022bef4e7b85cc5a39bf4bfe8ceebfeb90edbbfaa30a4530cdb1ecdee3bdb",
+"TT_test_protection_levels.py::test_signtx": "4621f78fbd00a23914ea986f540de8456c540dbe64702250a2b6d3222657929e",
+"TT_test_protection_levels.py::test_unlocked": "6e4edbd4e874fc02bbe223b429235e735231eb4a3eede7d6e0743e697455a49d",
+"TT_test_protection_levels.py::test_verify_message_t2": "ae4550276b95e8eed916e1fa786320bea6f03f722529a2f37fba6abb81ac9533",
 "TT_test_protection_levels.py::test_wipe_device": "a30d958dda50b06e8bfc1c861c0ff2c0eb4acd0656bdf1dcd6474660882e3cd5",
 "TT_test_sdcard.py::test_sd_format": "b6da09fabbf0f9f05e2b575650789b2ecae25bdcc0304e14c1e59fa1b4b24d05",
 "TT_test_sdcard.py::test_sd_no_format": "28237b70aadc1ce6f3ddfd3c0f9b6b256898cad068b0de333b404989aa0dcc62",
 "TT_test_sdcard.py::test_sd_protect_unlock": "bc654959615d17f6d8d6dda4625b4ecf7798a7d8c05ff438fc1546d0f8547432",
 "TT_test_session.py::test_cannot_resume_ended_session": "c09de07fbbf1e047442180e2facb5482d06a1a428891b875b7dd93c9e4704ae1",
-"TT_test_session.py::test_clear_session": "a749e7ff817a859da0670e7810d683909b9c4db415594098981183adb9c6be2e",
+"TT_test_session.py::test_clear_session": "3669c9dc54bff19d7ebe0ad1495656454dc1d846ff32278840c123833007f889",
 "TT_test_session.py::test_derive_cardano_empty_session": "c09de07fbbf1e047442180e2facb5482d06a1a428891b875b7dd93c9e4704ae1",
 "TT_test_session.py::test_derive_cardano_running_session": "c09de07fbbf1e047442180e2facb5482d06a1a428891b875b7dd93c9e4704ae1",
 "TT_test_session.py::test_end_session": "c09de07fbbf1e047442180e2facb5482d06a1a428891b875b7dd93c9e4704ae1",