diff --git a/include/libdap-crypto-python.h b/include/libdap-crypto-python.h
index d08e40119a00b1061d1787c4566849207c02d3b8..e5ff3218d891a13ecf8246aeab5d126f5c5c5c38 100644
--- a/include/libdap-crypto-python.h
+++ b/include/libdap-crypto-python.h
@@ -3,6 +3,7 @@
 #include "dap_enc.h"
 #include "dap_enc_key.h"
 #include "dap_common.h"
+//#include "libdap-crypto-key-python.h"
 #include "wrapping_base58.h"
 #include "wrapping_base64.h"
 #include "wrapping_dap_enc_key.h"
@@ -16,57 +17,94 @@ extern "C" {
 #undef LOG_TAG
 #define LOG_TAG "libdap-python-crypto"
 
-static PyObject *dap_crypto_init(PyObject *self, PyObject *args);
+typedef struct PyCrypto{
+    PyObject_HEAD
+}PyCryptoObject;
 
-static PyObject *dap_crypto_deinit();
+int dap_crypto_init(void);
 
-static PyObject *dap_log_it_debug(PyObject *self, PyObject *args);
+void dap_crypto_deinit(void);
 
-static PyObject *dap_log_it_info(PyObject *self, PyObject *args);
-
-static PyMethodDef DapCryptoMethods[] = {
-        {"init", dap_crypto_init, METH_VARARGS, "Initialization of the DAP (Deus Applicaions Prototypes) crypto library"},
-        {"deinit", dap_crypto_deinit, METH_NOARGS, "Deinitialization of the DAP (Deus Applicaions Prototypes) crypto library"},
-        {"encodeBase58", dap_encode_base58_py, METH_VARARGS, "Encrypts information using the base58 algorithm from the DAP crypto library"},
-        {"decodeBase58", dap_decode_base58_py, METH_VARARGS, "Dencrypts information using the base58 algorithm from the DAP crypto library"},
-        {"encodeBase64", dap_encode_base64_py, METH_VARARGS, "Encrypts information using the base64 algorithm from the DAP crypto library"},
-        {"decodeBase64", dap_decode_base64_py, METH_VARARGS, "Dencrypts information using the base64 algorithm from the DAP crypto library"},
-        {"logItDebug", dap_log_it_debug, METH_VARARGS, ""},
-        {"logItInfo", dap_log_it_info, METH_VARARGS, ""},
-        {"newKey", dap_enc_key_new_py, METH_VARARGS, "The function creates a new key, and returns it with PyObject."},
-        {"delKey", dap_enc_key_delete_py, METH_VARARGS, ""},
-        {"generateNewKey", dap_enc_key_new_generate_py, METH_VARARGS, ""},
-        {"getEncSizeKey", dap_enc_key_get_enc_size_py, METH_VARARGS, ""},
-        {"getDecSizeKey", dap_enc_key_get_dec_size_py, METH_VARARGS, ""},
+static PyMethodDef CryptoMethods[] = {
+        {"encodeBase58", dap_encode_base58_py, METH_VARARGS | METH_STATIC, "Encrypts information using the base58 algorithm from the DAP crypto library"},
+        {"decodeBase58", dap_decode_base58_py, METH_VARARGS | METH_STATIC, "Dencrypts information using the base58 algorithm from the DAP crypto library"},
+        {"encodeBase64", dap_encode_base64_py, METH_VARARGS | METH_STATIC, "Encrypts information using the base64 algorithm from the DAP crypto library"},
+        {"decodeBase64", dap_decode_base64_py, METH_VARARGS | METH_STATIC, "Dencrypts information using the base64 algorithm from the DAP crypto library"},
+        {"newKey", dap_enc_key_new_py, METH_VARARGS | METH_STATIC, "The function creates a new key, and returns it with PyObject."},
+        {"generateNewKey", dap_enc_key_new_generate_py, METH_VARARGS | METH_STATIC, ""},
+        {"getEncSizeKey", dap_enc_key_get_enc_size_py, METH_VARARGS | METH_STATIC, ""},
+        {"getDecSizeKey", dap_enc_key_get_dec_size_py, METH_VARARGS | METH_STATIC, ""},
         /*IAES256*/
-        {"newKeyIAES", dap_enc_iaes_key_new_py, METH_VARARGS, ""},
-        {"deleteKeyIAES", dap_enc_iaes_key_delete_py, METH_VARARGS, ""},
-        {"generateKeyIAES", dap_enc_iaes_key_generate_py, METH_VARARGS, ""},
-        {"encodeSizeIAES256", dap_enc_iaes256_calc_encode_size_py, METH_VARARGS, ""},
-        {"decodeSizeIAES256", dap_enc_iaes256_calc_decode_size_py, METH_VARARGS, ""},
-        {"encryptIAES256CBCFast", dap_enc_iaes256_cbc_encrypt_fast_py, METH_VARARGS, ""},
-        {"decryptIAES256CBCFast", dap_enc_iaes256_cbc_decrypt_fast_py, METH_VARARGS, ""},
+        {"newKeyIAES", dap_enc_iaes_key_new_py, METH_VARARGS | METH_STATIC, ""},
+        {"deleteKeyIAES", dap_enc_iaes_key_delete_py, METH_VARARGS | METH_STATIC, ""},
+        {"generateKeyIAES", dap_enc_iaes_key_generate_py, METH_VARARGS | METH_STATIC, ""},
+        {"encodeSizeIAES256", dap_enc_iaes256_calc_encode_size_py, METH_VARARGS | METH_STATIC, ""},
+        {"decodeSizeIAES256", dap_enc_iaes256_calc_decode_size_py, METH_VARARGS | METH_STATIC, ""},
+        {"encryptIAES256CBCFast", dap_enc_iaes256_cbc_encrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
+        {"decryptIAES256CBCFast", dap_enc_iaes256_cbc_decrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
         /*OAES*/
-        {"newKeyOAES", dap_enc_oaes_key_new_py, METH_VARARGS, ""},
-        {"deleteKeyOAES", dap_enc_oaes_key_delete_py, METH_VARARGS, ""},
-        {"generateKeyOAES", dap_enc_oaes_key_generate_py, METH_VARARGS, ""},
-        {"encodeSizeOAES", dap_enc_oaes_calc_encode_size_py, METH_VARARGS, ""},
-        {"decodeSizeOAES", dap_enc_oaes_calc_decode_size_py, METH_VARARGS, ""},
-        {"encryptOAESFast", dap_enc_oaes_encrypt_fast_py, METH_VARARGS, ""},
-        {"decryptOAESFast", dap_enc_oaes_decrypt_fast_py, METH_VARARGS, ""},
+        {"newKeyOAES", dap_enc_oaes_key_new_py, METH_VARARGS | METH_STATIC, ""},
+        {"deleteKeyOAES", dap_enc_oaes_key_delete_py, METH_VARARGS | METH_STATIC, ""},
+        {"generateKeyOAES", dap_enc_oaes_key_generate_py, METH_VARARGS | METH_STATIC, ""},
+        {"encodeSizeOAES", dap_enc_oaes_calc_encode_size_py, METH_VARARGS | METH_STATIC, ""},
+        {"decodeSizeOAES", dap_enc_oaes_calc_decode_size_py, METH_VARARGS | METH_STATIC, ""},
+        {"encryptOAESFast", dap_enc_oaes_encrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
+        {"decryptOAESFast", dap_enc_oaes_decrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
         {NULL, NULL, 0, NULL}
 };
 
-static struct PyModuleDef dapcryptomodule = {
-        PyModuleDef_HEAD_INIT,
-        "libdap_crypto_python_module",   /* name of module */
-        NULL, /* module documentation, may be NULL */
-        -1,       /* size of per-interpreter state of the module,
-                 or -1 if the module keeps state in global variables. */
-        DapCryptoMethods
+static PyTypeObject dapCrypto_dapCryptoType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "libCellFrame.Crypto",             /* tp_name */
+    sizeof(PyCryptoObject),             /* tp_basicsize */
+    0,                         /* tp_itemsize */
+    0,//(destructor)Noddy_dealloc, /* tp_dealloc */
+    0,                         /* tp_print */
+    0,                         /* tp_getattr */
+    0,                         /* tp_setattr */
+    0,                         /* tp_reserved */
+    0,                         /* tp_repr */
+    0,                         /* tp_as_number */
+    0,                         /* tp_as_sequence */
+    0,                         /* tp_as_mapping */
+    0,                         /* tp_hash  */
+    0,                         /* tp_call */
+    0,                         /* tp_str */
+    0,                         /* tp_getattro */
+    0,                         /* tp_setattro */
+    0,                         /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT |
+        Py_TPFLAGS_BASETYPE,   /* tp_flags */
+    "Crypto objects",           /* tp_doc */
+    0,		               /* tp_traverse */
+    0,		               /* tp_clear */
+    0,		               /* tp_richcompare */
+    0,		               /* tp_weaklistoffset */
+    0,		               /* tp_iter */
+    0,		               /* tp_iternext */
+    CryptoMethods,             /* tp_methods */
+    0,                         /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    0,//(initproc)PyDapEventsObject_init,//(initproc)Noddy_init,      /* tp_init */
+    0,                         /* tp_alloc */
+    PyType_GenericNew,//PyDapEventsObject_new,//Noddy_new,                 /* tp_new */
 };
 
-PyMODINIT_FUNC PyInit_libdap_crypto_python_module(void);
+//static struct PyModuleDef dapcryptomodule = {
+//        PyModuleDef_HEAD_INIT,
+//        "libdap_crypto_python_module",   /* name of module */
+//        NULL, /* module documentation, may be NULL */
+//        -1,       /* size of per-interpreter state of the module,
+//                 or -1 if the module keeps state in global variables. */
+//        DapCryptoMethods
+//};
+
+//PyMODINIT_FUNC PyInit_libdap_crypto_python_module(void);
 
 #ifdef  __cplusplus
 }
diff --git a/include/wrapping_dap_enc_iaes.h b/include/wrapping_dap_enc_iaes.h
index c2a9f0078c6318e74db0bc6fedc855e95bdc2144..e531d6cfd42315b9a65ca0be2139b17e90ec5ee6 100644
--- a/include/wrapping_dap_enc_iaes.h
+++ b/include/wrapping_dap_enc_iaes.h
@@ -1,6 +1,10 @@
+#ifndef WRAPPING_DAP_ENC_IAES_
+#define WRAPPING_DAP_ENC_IAES_
+
 #include "Python.h"
 #include "dap_enc_iaes.h"
-#include "key_list.h"
+#include "dap_common.h"
+#include "libdap_crypto_key_python.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -9,8 +13,6 @@ extern "C" {
 #undef LOG_TAG
 #define LOG_TAG "wrapping-dap-enc-iaes"
 
-key_list_t *keys_iaes;
-
 PyObject* dap_enc_iaes_key_new_py(PyObject *self, PyObject *args);
 
 PyObject* dap_enc_iaes_key_delete_py(PyObject *self, PyObject *args);
@@ -30,3 +32,5 @@ PyObject* dap_enc_iaes256_cbc_encrypt_fast_py(PyObject *self, PyObject *args);
 #ifdef __cplusplus
 }
 #endif
+
+#endif //WRAPPING_DAP_ENC_IAES_
diff --git a/include/wrapping_dap_enc_key.h b/include/wrapping_dap_enc_key.h
index b57bd12c5e902e42a36ae901675d4294494c5edd..e1ea507e74feb476703dcc1fa9797fc98ade9421 100644
--- a/include/wrapping_dap_enc_key.h
+++ b/include/wrapping_dap_enc_key.h
@@ -1,7 +1,10 @@
+#ifndef WRAPPING_DAP_ENC_KEY_
+#define WRAPPING_DAP_ENC_KEY_
+
 #include "dap_enc_key.h"
 #include "Python.h"
 #include "dap_common.h"
-#include "key_list.h"
+#include "libdap_crypto_key_python.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -10,8 +13,6 @@ extern "C" {
 #undef LOG_TAG
 #define LOG_TAG "wrapping-dap-enc-key"
 
-key_list_t *keys;
-
 PyObject* dap_enc_key_get_enc_size_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key, const size_t buf_in_size); -> size_t
 PyObject* dap_enc_key_get_dec_size_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key, const size_t buf_in_size); -> size_t
 
@@ -38,6 +39,9 @@ PyObject *dap_enc_gen_key_public_py(PyObject *self, PyObject *args);//dap_enc_ke
 PyObject *dap_enc_key_signature_delete_py(PyObject *self, PyObject *args);//dap_enc_key_type_t a_key_type, uint8_t *a_sig_buf);     ->void
 PyObject *dap_enc_key_delete_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key);       ->void
 
+
 #ifdef __cplusplus
 }
 #endif
+
+#endif //WRAPPING_DAP_ENC_KEY_
diff --git a/include/wrapping_dap_enc_oaes.h b/include/wrapping_dap_enc_oaes.h
index 1498a9297c79fd364aa4cfe58a26cc374c48acf9..823b44b43ccd2d7751b9ba250285d63b71594573 100644
--- a/include/wrapping_dap_enc_oaes.h
+++ b/include/wrapping_dap_enc_oaes.h
@@ -1,13 +1,15 @@
+#ifndef WRAPPING_DAP_ENC_OAES_
+#define WRAPPING_DAP_ENC_OAES_
+
 #include "Python.h"
 #include "dap_enc_oaes.h"
-#include "key_list.h"
+#include "dap_common.h"
+#include "libdap_crypto_key_python.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-key_list_t *keys_oaes;
-
 PyObject *dap_enc_oaes_key_new_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key);
 PyObject *dap_enc_oaes_key_delete_py(PyObject *self, PyObject *args);//struct dap_enc_key *a_key);
 PyObject *dap_enc_oaes_key_generate_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void *kex_buf,
@@ -30,3 +32,5 @@ PyObject *dap_enc_oaes_encrypt_fast_py(PyObject *self, PyObject *args);//struct
 #ifdef __cplusplus
 }
 #endif
+
+#endif //WRAPPING_DAP_ENC_OAES_
diff --git a/src/libdap-crypto-python.c b/src/libdap-crypto-python.c
index cff1369c0ed64610d5a3fb0a829cfe5515cf8f37..5b645c12835f21ced1fae1f7674c9e1d0a5eaa25 100644
--- a/src/libdap-crypto-python.c
+++ b/src/libdap-crypto-python.c
@@ -9,16 +9,13 @@ int dap_crypto_init(void){
         log_it(L_CRITICAL,"Can't init encryption key module");
         return -2;
     }
-    keys = key_list_init();
-    keys_iaes = keys;
-    keys_oaes = keys;
+    PyCryptoKeyObject_PyCryptoKeyType.tp_new = PyType_GenericNew;
     return 0;
 }
 
 void dap_crypto_deinit(void){
     dap_enc_key_deinit();
     dap_enc_deinit();
-    key_list_free(keys);
 }
 
 
diff --git a/src/wrapping_dap_enc_iaes.c b/src/wrapping_dap_enc_iaes.c
index d7cc58017d25faf18175ef2adf49dac3aa4c27d6..773077945e28627fcd57be8bc9c6500e54f52037 100644
--- a/src/wrapping_dap_enc_iaes.c
+++ b/src/wrapping_dap_enc_iaes.c
@@ -2,51 +2,52 @@
 
 
 PyObject* dap_enc_iaes_key_new_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
-    if (PyArg_ParseTuple(args, "h", &key_id)){
+    PyObject *obj_key;
+    if (PyArg_ParseTuple(args, "O", &obj_key)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
-    if (key == NULL){
-        return NULL;
-    }
-    dap_enc_aes_key_new(key);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    dap_enc_aes_key_new(((PyCryptoKeyObject*)obj_key)->key);
     return  PyLong_FromLong(0);
 }
 
 PyObject* dap_enc_iaes_key_delete_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
-    if (PyArg_ParseTuple(args, "h", &key_id)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
-    if (key == NULL){
+    PyObject *obj_key;
+    if (PyArg_ParseTuple(args, "O", &obj_key)){
         return NULL;
     }
-    dap_enc_key_delete(key);
+//    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+//    dap_enc_key_delete(((PyCryptoKeyObject*)obj_key)->key);
+    PyObject_Del(obj_key);
     return  PyLong_FromLong(0);
 }
 
 PyObject* dap_enc_iaes_key_generate_py(PyObject *self, PyObject *args){
     // TODO
-    uint8_t in_key_id;
+    PyObject* in_key;
     PyBytesObject *in_kex_buf;
     size_t in_kex_size;
     PyBytesObject *in_seed;
     size_t in_seed_size;
-    if (PyArg_ParseTuple(args, "h|S|n|S|n", &in_key_id, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
+    if (PyArg_ParseTuple(args, "O|S|n|S|n", &in_key, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys_iaes, in_key_id);
-    if (key == NULL){
-        return NULL;
-    }
-    size_t key_size = sizeof(key);
+//    dap_enc_key_t *key = key_list_get_key(keys_iaes, in_key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+//    PyObject *new_key = _PyObject_New(&PyCryptoKeyObject_PyCryptoKeyType);
+    size_t key_size = sizeof(((PyCryptoKeyObject*)in_key)->key);
     void* kex_buf = NULL;
     PyBytes_AsStringAndSize((PyObject*)in_kex_buf, kex_buf, (Py_ssize_t*)in_kex_size);
     void* seed_buf = NULL;
     PyBytes_AsStringAndSize((PyObject*)in_seed, seed_buf, (Py_ssize_t*)in_seed_size);
-    dap_enc_aes_key_generate(key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
+    dap_enc_aes_key_generate(((PyCryptoKeyObject*)in_key)->key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
     return  PyLong_FromLong(0);
 }
 
@@ -111,40 +112,36 @@ PyObject* dap_enc_iaes256_cbc_encrypt_py(PyObject *self, PyObject *args){
 
 // Writes result ( out ) in already allocated buffer
 PyObject* dap_enc_iaes256_cbc_decrypt_fast_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject* in_key;
     PyBytesObject *a_in;
     size_t a_in_size;
     size_t buf_out_size;
-    if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
-    if (key == NULL){
+    if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
         return NULL;
     }
+//    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
     void *in = PyBytes_AsString((PyObject*)a_in);
     void *out = DAP_NEW_SIZE(void*, buf_out_size);
-    size_t res_denc_size = dap_enc_iaes256_cbc_decrypt_fast(key, in, a_in_size, out, buf_out_size);
+    size_t res_denc_size = dap_enc_iaes256_cbc_decrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
     PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_denc_size);
     return Py_BuildValue("S", bytes_out);
 }
 
 // if "a_in size mod IAES_BLOCK_SIZE = 0" encryption will be faster
 PyObject* dap_enc_iaes256_cbc_encrypt_fast_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject *in_key;
     PyBytesObject *a_in;
     size_t a_in_size;
     size_t buf_out_size;
-    if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
-    if (key == NULL){
+    if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
         return NULL;
     }
     void *in = PyBytes_AsString((PyObject*)a_in);
     void *out = DAP_NEW_SIZE(void*, buf_out_size);
-    size_t res_enc_size = dap_enc_iaes256_cbc_encrypt_fast(key, in, a_in_size, out, buf_out_size);
+    size_t res_enc_size = dap_enc_iaes256_cbc_encrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
     PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_enc_size);
     return Py_BuildValue("S", bytes_out);
 }
diff --git a/src/wrapping_dap_enc_key.c b/src/wrapping_dap_enc_key.c
index 359efebb4bb1bfda3483de3896ed3e5b6863e1f5..01356fe995851df44e70c78640f866ce6525abbb 100644
--- a/src/wrapping_dap_enc_key.c
+++ b/src/wrapping_dap_enc_key.c
@@ -1,30 +1,30 @@
 #include "wrapping_dap_enc_key.h"
 
 PyObject* dap_enc_key_get_enc_size_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject *in_key;
     size_t buff_in_size;
-    if (!PyArg_ParseTuple(args, "h|i"), &key_id, &buff_in_size){
+    if (!PyArg_ParseTuple(args, "O|i", &in_key, &buff_in_size)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL)
-        return NULL;
-    size_t size_buff = dap_enc_key_get_enc_size(key, buff_in_size);
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL)
+//        return NULL;
+    size_t size_buff = dap_enc_key_get_enc_size(((PyCryptoKeyObject*)in_key)->key, buff_in_size);
     if (size_buff == 0)
         return NULL;
     return  PyLong_FromSize_t(size_buff);
 }
 
 PyObject* dap_enc_key_get_dec_size_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject *in_key;
     size_t buff_in_size;
-    if (!PyArg_ParseTuple(args, "h|i"), &key_id, &buff_in_size){
+    if (!PyArg_ParseTuple(args, "O|i", &in_key, &buff_in_size)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL)
-        return NULL;
-    size_t size_buff = dap_enc_key_get_dec_size(key, buff_in_size);
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL)
+//        return NULL;
+    size_t size_buff = dap_enc_key_get_dec_size(((PyCryptoKeyObject*)in_key)->key, buff_in_size);
     if (size_buff == 0)
         return NULL;
     return  PyLong_FromSize_t(size_buff);
@@ -40,8 +40,9 @@ PyObject* dap_enc_key_new_py(PyObject *self, PyObject *args){
         return PyLong_FromLong(-1);
     }
     dap_enc_key_t *new_key = dap_enc_key_new(type_key);
-    uint8_t res = key_list_add_element(keys, new_key);
-    return  PyLong_FromLong(res);
+    PyObject *obj = _PyObject_New(&PyCryptoKeyObject_PyCryptoKeyType);
+    ((PyCryptoKeyObject*)obj)->key = new_key;
+    return  Py_BuildValue("O", obj);
 }
 
 /// default gen key
@@ -65,22 +66,22 @@ PyObject *dap_enc_key_new_generate_py(PyObject *self, PyObject *args){
         kex_buf = PyBytes_AsString((PyObject*)in_kex_buf);
     if (in_seed_size != 0)
         seed = PyBytes_AsString((PyObject*)in_seed);
-    dap_enc_key_t *new_key = dap_enc_key_new_generate(in_type_key, kex_buf, in_kex_size, seed, in_seed_size, in_key_size);
-    uint8_t new_key_id = key_list_add_element(keys, new_key);
-    return PyLong_FromLong(new_key_id);
+    PyCryptoKeyObject *obj_key = (PyCryptoKeyObject*)_PyObject_New(&PyCryptoKeyObject_PyCryptoKeyType);
+    obj_key->key = dap_enc_key_new_generate(in_type_key, kex_buf, in_kex_size, seed, in_seed_size, in_key_size);
+    return  Py_BuildValue("O", (PyObject*)obj_key);
 }
 
 // update struct dap_enc_key_t after insert foreign keys
 PyObject* dap_enc_key_update_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
-    if (!PyArg_ParseTuple(args, "h", &key_id)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL) {
+    PyObject *in_key;
+    if (!PyArg_ParseTuple(args, "O", &in_key)){
         return NULL;
     }
-    dap_enc_key_update(key);
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL) {
+//        return NULL;
+//    }
+    dap_enc_key_update(((PyCryptoKeyObject*)in_key)->key);
     return PyLong_FromLong(0);
 }
 
@@ -91,29 +92,29 @@ PyObject *dap_enc_gen_pub_key_from_priv_py(PyObject *self, PyObject *args){ //NO
 
 
 PyObject *dap_enc_gen_key_public_size_py(PyObject *self, PyObject *args){
-    uint8_t  key_id;
-    if (PyArg_ParseTuple(args, "h", &key_id)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL){
+    PyObject *in_key;
+    if (PyArg_ParseTuple(args, "h", &in_key)){
         return NULL;
     }
-    size_t size = dap_enc_gen_key_public_size(key);
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    size_t size = dap_enc_gen_key_public_size(((PyCryptoKeyObject*)in_key)->key);
     return PyLong_FromSize_t(size);
 }
 
 PyObject *dap_enc_gen_key_public_py(PyObject *self, PyObject *args){
-    uint8_t  key_id;
+    PyObject *in_key;
     PyObject *obj;
-    if (PyArg_ParseTuple(args, "h|O", &key_id, &obj)){
+    if (PyArg_ParseTuple(args, "O|O", &in_key, &obj)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL){
-        return NULL;
-    }
-    int size = dap_enc_gen_key_public(key, obj);
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    int size = dap_enc_gen_key_public(((PyCryptoKeyObject*)in_key)->key, obj);
     return PyLong_FromLong(size);
 }
 
@@ -134,15 +135,17 @@ PyObject *dap_enc_key_signature_delete_py(PyObject *self, PyObject *args){
 
 PyObject *dap_enc_key_delete_py(PyObject *self, PyObject *args){
     //PyObject *obj;
-    uint8_t key_id;
-    if (!PyArg_ParseTuple(args, "h", &key_id)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys, key_id);
-    if (key == NULL) {
-        return NULL;
-    }
-    key_list_del_element(keys, key_id);
-    dap_enc_key_delete(key);
+    PyObject *in_key;
+    if (!PyArg_ParseTuple(args, "O", &in_key)){
+        return NULL;
+    }
+//    dap_enc_key_t *key = key_list_get_key(keys, key_id);
+//    if (key == NULL) {
+//        return NULL;
+//    }
+//    key_list_del_element(keys, key_id);
+//    dap_enc_key_delete(((PyCryptoKeyObject*)in_key)->key);
+//    PyObject_Del(in_key);
+//    PyCryptoKeyObject_dealloc((PyCryptoKeyObject*)in_key);
     return PyLong_FromLong(0);
 }
diff --git a/src/wrapping_dap_enc_oaes.c b/src/wrapping_dap_enc_oaes.c
index 5e2ef99cc1a67edb24013bc01aab03e84e5f04ea..36b47fa1a0e36cb4a269906e2e883106fac7624d 100644
--- a/src/wrapping_dap_enc_oaes.c
+++ b/src/wrapping_dap_enc_oaes.c
@@ -2,48 +2,49 @@
 
 
 PyObject *dap_enc_oaes_key_new_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
-    if (PyArg_ParseTuple(args, "h", &key_id)){
+    PyObject *in_key;
+    if (PyArg_ParseTuple(args, "O", &in_key)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
-    if (key == NULL){
-        return NULL;
-    }
-    dap_enc_oaes_key_new(key);
+//    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    dap_enc_oaes_key_new(((PyCryptoKeyObject*)in_key)->key);
     return  PyLong_FromLong(0);
 }
 PyObject *dap_enc_oaes_key_delete_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
-    if (PyArg_ParseTuple(args, "h", &key_id)){
+    PyObject *in_key;
+    if (PyArg_ParseTuple(args, "O", &in_key)){
         return NULL;
     }
-    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
-    if (key == NULL){
-        return NULL;
-    }
-    dap_enc_key_delete(key);
+//    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    dap_enc_key_delete(((PyCryptoKeyObject*)in_key)->key);
+    PyObject_Del(in_key);
     return  PyLong_FromLong(0);
 }
 PyObject *dap_enc_oaes_key_generate_py(PyObject *self, PyObject *args){
-    uint8_t in_key_id;
+    PyObject *in_key;
     PyBytesObject *in_kex_buf;
     size_t in_kex_size;
     PyBytesObject *in_seed;
     size_t in_seed_size;
-    if (PyArg_ParseTuple(args, "h|S|n|S|n", &in_key_id, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_oaes, in_key_id);
-    if (key == NULL){
+    if (PyArg_ParseTuple(args, "O|S|n|S|n", &in_key, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
         return NULL;
     }
-    size_t key_size = sizeof(key);
+//    dap_enc_key_t *key = key_list_get_key(keys_oaes, in_key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
+    size_t key_size = sizeof(((PyCryptoKeyObject*)in_key)->key);
     void* kex_buf = NULL;
     PyBytes_AsStringAndSize((PyObject*)in_kex_buf, kex_buf, (Py_ssize_t*)in_kex_size);
     void* seed_buf = NULL;
     PyBytes_AsStringAndSize((PyObject*)in_seed, seed_buf, (Py_ssize_t*)in_seed_size);
-    dap_enc_oaes_key_generate(key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
+    dap_enc_oaes_key_generate(((PyCryptoKeyObject*)in_key)->key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
     return  PyLong_FromLong(0);
 }
 
@@ -75,39 +76,39 @@ PyObject *dap_enc_oaes_encrypt_py(PyObject *self, PyObject *args){
 
 // Writes result ( out ) in already allocated buffer
 PyObject *dap_enc_oaes_decrypt_fast_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject *in_key;
     PyBytesObject *a_in;
     size_t a_in_size;
     size_t buf_out_size;
-    if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
-    if (key == NULL){
+    if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
         return NULL;
     }
+//    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
     void *in = PyBytes_AsString((PyObject*)a_in);
     void *out = DAP_NEW_SIZE(void*, buf_out_size);
-    size_t res_denc_size = dap_enc_oaes_decrypt_fast(key, in, a_in_size, out, buf_out_size);
+    size_t res_denc_size = dap_enc_oaes_decrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
     PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_denc_size);
     return Py_BuildValue("S", bytes_out);
 }
 // Writes result ( out ) in already allocated buffer
 PyObject *dap_enc_oaes_encrypt_fast_py(PyObject *self, PyObject *args){
-    uint8_t key_id;
+    PyObject *in_key;
     PyBytesObject *a_in;
     size_t a_in_size;
     size_t buf_out_size;
-    if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
-        return NULL;
-    }
-    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
-    if (key == NULL){
+    if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
         return NULL;
     }
+//    dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
+//    if (key == NULL){
+//        return NULL;
+//    }
     void *in = PyBytes_AsString((PyObject*)a_in);
     void *out = DAP_NEW_SIZE(void*, buf_out_size);
-    size_t res_enc_size = dap_enc_oaes_encrypt_fast(key, in, a_in_size, out, buf_out_size);
+    size_t res_enc_size = dap_enc_oaes_encrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
     PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_enc_size);
     return Py_BuildValue("S", bytes_out);
 }