diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000000000000000000000000000000000..222a8235d19134c1075d8499b214c9c45d841122
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,69 @@
+[submodule "libdap-chain-net"]
+ path = libdap-chain-net
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-net.git
+[submodule "libdap"]
+ path = libdap
+ url = https://gitlab.demlabs.net/cellframe/libdap.git
+[submodule "libdap-crypto"]
+ path = libdap-crypto
+ url = https://gitlab.demlabs.net/cellframe/libdap-crypto.git
+[submodule "libdap-client"]
+ path = libdap-client
+ url = https://gitlab.demlabs.net/cellframe/libdap-client.git
+[submodule "libdap-stream-ch-chain"]
+ path = libdap-stream-ch-chain
+ url = https://gitlab.demlabs.net/cellframe/libdap-stream-ch-chain.git
+[submodule "libdap-chain-gdb"]
+ path = libdap-chain-gdb
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-gdb.git
+[submodule "libdap-stream-ch-chain-net"]
+ path = libdap-stream-ch-chain-net
+ url = https://gitlab.demlabs.net/cellframe/libdap-stream-ch-chain-net.git
+[submodule "libdap-chain"]
+ path = libdap-chain
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain.git
+[submodule "libdap-chain-crypto"]
+ path = libdap-chain-crypto
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-crypto.git
+[submodule "libdap-chain-wallet"]
+ path = libdap-chain-wallet
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-wallet.git
+[submodule "libdap-chain-net-srv"]
+ path = libdap-chain-net-srv
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-net-srv.git
+[submodule "libdap-chain-net-srv-vpn"]
+ path = libdap-chain-net-srv-vpn
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-net-srv-vpn.git
+[submodule "libdap-chain-mempool"]
+ path = libdap-chain-mempool
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-mempool.git
+[submodule "libdap-chain-global-db"]
+ path = libdap-chain-global-db
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-global-db.git
+[submodule "libdap-server"]
+ path = libdap-server
+ url = https://gitlab.demlabs.net/cellframe/libdap-server.git
+[submodule "libdap-server-core"]
+ path = libdap-server-core
+ url = https://gitlab.demlabs.net/cellframe/libdap-server-core.git
+[submodule "libdap-stream"]
+ path = libdap-stream
+ url = https://gitlab.demlabs.net/cellframe/libdap-stream.git
+[submodule "libdap-stream-ch"]
+ path = libdap-stream-ch
+ url = https://gitlab.demlabs.net/cellframe/libdap-stream-ch.git
+[submodule "libdap-server-udp"]
+ path = libdap-server-udp
+ url = https://gitlab.demlabs.net/cellframe/libdap-server-udp.git
+[submodule "libdap-chain-python"]
+ path = libdap-chain-python
+ url = https://gitlab.demlabs.net/cellframe/libdap-chain-python.git
+[submodule "libdap-crypto-python"]
+ path = libdap-crypto-python
+ url = https://gitlab.demlabs.net/cellframe/libdap-crypto-python.git
+[submodule "libdap-python"]
+ path = libdap-python
+ url = https://gitlab.demlabs.net/cellframe/libdap-python.git
+[submodule "libdap-client-python"]
+ path = libdap-client-python
+ url = https://gitlab.demlabs.net/cellframe/libdap-client-python.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..346efd1f086f6b9ff6c454e6af1af5a8b105b9d7
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,224 @@
+project(dap_chain_net_python_module C)
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_COLOR_MAKEFILE ON)
+set(CMAKE_C_STANDARD 11)
+add_definitions("-fpic")
+add_definitions ("-DNODE_NETNAME=\"cellframe\"")
+
+if(UNIX)
+ add_definitions("-DDAP_OS_UNIX")
+endif()
+
+if(NOT (${SUBMODULES_NO_BUILD} MATCHES ON))
+ set (SUBMODULES_NO_BUILD ON)
+ if (NOT (TARGET dap_core))
+ add_subdirectory(libdap)
+ target_compile_options(
+ dap_core PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_crypto))
+ add_subdirectory(libdap-crypto)
+ target_compile_options(
+ dap_crypto PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain))
+ add_subdirectory(libdap-chain)
+ target_compile_options(
+ dap_chain PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_crypto))
+ add_subdirectory(libdap-chain-crypto)
+ target_compile_options(
+ dap_chain_crypto PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_mempool))
+ add_subdirectory(libdap-chain-mempool)
+ target_compile_options(
+ dap_chain_mempool PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_net))
+ add_subdirectory(libdap-chain-net)
+ target_compile_options(
+ dap_chain_net PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_server_core))
+ add_subdirectory(libdap-server-core)
+ target_compile_options(
+ dap_server_core PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_global_db))
+ add_subdirectory(libdap-chain-global-db)
+ target_compile_options(
+ dap_chain_global_db PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_client))
+ add_subdirectory(libdap-client)
+ target_compile_options(
+ dap_client PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET libdap-server))
+ add_subdirectory(libdap-server)
+# target_compile_options(
+# libdap-server PRIVATE
+# "-fpic"
+# )
+ endif()
+ if (NOT (TARGET dap_stream))
+ add_subdirectory(libdap-stream)
+ target_compile_options(
+ dap_stream PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_stream_ch))
+ add_subdirectory(libdap-stream-ch)
+ target_compile_options(
+ dap_stream_ch PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_stream_ch_chain))
+ add_subdirectory(libdap-stream-ch-chain)
+ target_compile_options(
+ dap_stream_ch_chain PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_stream_ch_chain_net))
+ add_subdirectory(libdap-stream-ch-chain-net)
+ target_compile_options(
+ dap_stream_ch_chain_net PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_udp_server))
+ add_subdirectory(libdap-server-udp)
+ target_compile_options(
+ dap_udp_server PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_net_srv))
+ add_subdirectory(libdap-chain-net-srv)
+ target_compile_options(
+ dap_chain_net_srv PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_wallet))
+ add_subdirectory(libdap-chain-wallet)
+ target_compile_options(
+ dap_chain_wallet PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_gdb))
+ add_subdirectory(libdap-chain-gdb)
+ target_compile_options(
+ dap_chain_gdb PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_python_module))
+ add_subdirectory(libdap-python)
+ target_compile_options(
+ dap_python_module PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_crypto_python_module))
+ add_subdirectory(libdap-crypto-python)
+ target_compile_options(
+ dap_crypto_python_module PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_net_srv_vpn))
+ add_subdirectory(libdap-chain-net-srv-vpn)
+ target_compile_options(
+ dap_chain_net_srv_vpn PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_chain_python_module))
+ add_subdirectory(libdap-chain-python)
+ target_compile_options(
+ dap_chain_python_module PRIVATE
+ "-fpic"
+ )
+ endif()
+ if (NOT (TARGET dap_client_python_module))
+ add_subdirectory(libdap-client-python)
+ target_compile_options(
+ dap_client_python_module PRIVATE
+ "-fpic"
+ )
+ endif()
+endif()
+#add_definitions("-DDAP_APP_NAME=\"TestPRJ\" -DSYSTEM_CONFIGS_DIR=\"${CMAKE_CURRENT_BINARY_DIR}\"")
+
+file(GLOB CHAIN_NET_PYTHON_SRCS src/*.c)
+file(GLOB CHAIN_NET_PYTHON_HEADERS include/*.h)
+
+set(Python_ADDITIONAL_VERSIONS 3.7)
+find_package (PythonLibs REQUIRED)
+include_directories(${PYTHON_INCLUDE_DIR} include/)
+
+add_library(${PROJECT_NAME} STATIC ${CHAIN_NET_PYTHON_SRCS} ${CHAIN_NET_PYTHON_HEADERS})
+
+target_link_libraries(${PROJECT_NAME})
+
+#target_compile_options(
+# dap_core PRIVATE
+# "-fpic"
+#)
+#target_compile_options(
+# dap_crypto PRIVATE
+# "-fpic"
+#)
+
+
+target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_chain dap_chain_crypto dap_server_core dap_chain_net dap_chain_python_module dap_client_python_module)
+#target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_chain dap_chain_global_db dap_chain_crypto dap_chain_mempool
+#
+# ) #dap_chain_crypto dap_chain_mempool dap_chain_global_db )
+#target_link_libraries(${PROJECT_NAME} dap_core dap_crypto)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include/ )
+
+#if(BUILD_DAP_CRYPTO_PYTHON_TESTS)
+# add_subdirectory(test)
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_b58.py
+# DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_b64.py
+# DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_iaes256_cbc.py
+# DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_iaes256_cbc.py
+# DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+# file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_oaes.py
+# DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+
+
+#endif()
+
diff --git a/include/libdap_chain_net_python.h b/include/libdap_chain_net_python.h
new file mode 100644
index 0000000000000000000000000000000000000000..d74e8eb65bb78535b4463f74b00a4acf978137b9
--- /dev/null
+++ b/include/libdap_chain_net_python.h
@@ -0,0 +1,123 @@
+#ifndef _WRAPPING_DAP_NET_PYTHON_
+#define _WRAPPING_DAP_NET_PYTHON_
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "dap_chain_net.h"
+#include "wrapping_dap_chain_net_state.h"
+//#include "wrapping_dap_chain_net_state.h"
+#include "wrapping_dap_chain_common_objects.h"
+#include "wrapping_dap_chain_ledger.h"
+#include "libdap-chain-python.h"
+#include "libdap_chain_type_python.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct PyDapChainNet{
+ PyObject_HEAD
+ dap_chain_net_t *chain_net;
+}PyDapChainNetObject;
+
+int dap_chain_net_init_py(void);
+void dap_chain_net_deinit_py(void);
+
+PyObject *dap_chain_net_load_all_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_state_go_to_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_start_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_stop_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_links_establish_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_sync_chains_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_sync_gdb_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_sync_all_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_net_proc_datapool_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_net_by_name_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_by_id_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_id_by_name_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_ledger_by_net_name_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_net_get_chain_by_name_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_net_get_cur_addr_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_get_cur_cell_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_get_cur_addr_int_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_net_get_gdb_group_mempool_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_get_gdb_group_mempool_by_chain_type_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_links_connect_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_net_get_chain_by_chain_type_py(PyObject *self, PyObject *args);
+
+static PyMethodDef DapChainNetMethods[] = {
+ {"loadAll", dap_chain_net_load_all_py, METH_NOARGS | METH_STATIC, ""},
+ {"stateGoTo", dap_chain_net_state_go_to_py, METH_VARARGS, ""},
+ {"start", dap_chain_net_start_py, METH_VARARGS, ""},
+ {"stop", dap_chain_net_stop_py, METH_VARARGS, ""},
+ {"linksEstablish", dap_chain_net_links_establish_py, METH_VARARGS, ""},
+ {"syncChains", dap_chain_net_sync_all_py, METH_VARARGS, ""},
+ {"syncGdb", dap_chain_net_sync_gdb_py, METH_VARARGS, ""},
+ {"syncAll", dap_chain_net_sync_all_py, METH_VARARGS, ""},
+ {"procDatapool", dap_chain_net_proc_datapool_py, METH_VARARGS, ""},
+ {"byName", dap_chain_net_by_name_py, METH_VARARGS | METH_STATIC, ""},
+ {"byId", dap_chain_net_by_id_py, METH_VARARGS | METH_STATIC, ""},
+ {"idByName", dap_chain_net_id_by_name_py, METH_VARARGS | METH_STATIC, ""},
+ {"ledgerByNetName", dap_chain_ledger_by_net_name_py, METH_VARARGS | METH_STATIC, ""},
+ {"getChainByName", dap_chain_net_get_chain_by_name_py, METH_VARARGS, ""},
+ {"getCurAddr", dap_chain_net_get_cur_addr_py, METH_VARARGS, ""},
+ {"getCurCell", dap_chain_net_get_cur_cell_py, METH_VARARGS, ""},
+ {"getGdbGroupMempool", dap_chain_net_get_gdb_group_mempool_py, METH_VARARGS | METH_STATIC, ""},
+ {"getGdbGroupMempoolByChainType", dap_chain_net_get_gdb_group_mempool_by_chain_type_py, METH_VARARGS, ""},
+ {"linksConnect", dap_chain_net_links_connect_py, METH_VARARGS, ""},
+ {"getChainByChainType", dap_chain_net_get_chain_by_chain_type_py, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNetObject_DapChainNetObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.ChainNet", /* tp_name */
+ sizeof(PyDapChainNetObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ DapChainNetMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_WRAPPING_DAP_NET_PYTHON_
diff --git a/include/wrapping_dap_chain_net_node.h b/include/wrapping_dap_chain_net_node.h
new file mode 100644
index 0000000000000000000000000000000000000000..1aefe1d44aef648505cff0acc081d6dd028aa476
--- /dev/null
+++ b/include/wrapping_dap_chain_net_node.h
@@ -0,0 +1,70 @@
+#ifndef _WRAPPING_DAP_CHAIN_NET_NODE_
+#define _WRAPPING_DAP_CHAIN_NET_NODE_
+
+#include <Python.h>
+#include "dap_chain_node.h"
+#include "wrapping_dap_chain_common_objects.h"
+#include "libdap_chain_net_python.h"
+
+typedef struct PyDapChainNode{
+ PyObject_HEAD
+}PyDapChainNodeObject;
+
+PyObject *dap_chain_node_gen_addr_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_check_addr_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_alias_find_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_alias_register_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_alias_delete_py(PyObject *self, PyObject *args);
+
+static PyMethodDef DapChainNetNodeMethods[] = {
+ {"genAddr", dap_chain_node_gen_addr_py, METH_VARARGS | METH_STATIC, ""},
+ {"checkAddr", dap_chain_node_check_addr_py, METH_VARARGS | METH_STATIC, ""},
+ {"aliasFind", dap_chain_node_alias_find_py, METH_VARARGS | METH_STATIC, ""},
+ {"aliasRegister", dap_chain_node_alias_register_py, METH_VARARGS | METH_STATIC, ""},
+ {"aliasDelete", dap_chain_node_alias_delete_py, METH_VARARGS | METH_STATIC, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNodeInfoObject_DapChainNodeInfoObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Chain.Node", /* tp_name */
+ sizeof(PyDapChainNodeObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net node object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ DapChainNetNodeMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#endif //_WRAPPING_DAP_CHAIN_NET_NODE_
diff --git a/include/wrapping_dap_chain_net_node_cli.h b/include/wrapping_dap_chain_net_node_cli.h
new file mode 100644
index 0000000000000000000000000000000000000000..8d027837fee7dd2f761ae180c70b6db1dc743d36
--- /dev/null
+++ b/include/wrapping_dap_chain_net_node_cli.h
@@ -0,0 +1,87 @@
+#ifndef _WRAPPING_DAP_CHAIN_NET_NODE_CLI_
+#define _WRAPPING_DAP_CHAIN_NET_NODE_CLI_
+
+#include <Python.h>
+#include "dap_config.h"
+#include "dap_chain_node_cli.h"
+#include "dap_chain_node_cli_cmd.h"
+#include "wrapping_dap_chain_common_objects.h"
+#include "wrapping_dap_chain_net_node.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct PyDapChainNodeCli{
+ PyObject_HEAD
+ cmdfunc_t *func;
+}PyDapChainNodeCliObject;
+static PyObject *binded_object_cmdfunc = NULL;
+
+int dap_chain_node_cli_init_py(dap_config_t *g_config);
+void dap_chain_node_cli_delete_py(void);
+
+PyObject *DapChainNodeCliObject_new(PyTypeObject *type_object, PyObject *args, PyObject *kwds);
+
+PyObject *dap_chain_node_cli_cmd_item_create_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_cli_set_reply_text_py(PyObject *self, PyObject *args);
+
+PyObject *dap_chain_node_addr_get_by_alias_py(PyObject *self, PyObject *args);
+
+static PyMethodDef DapChainNodeCliMethods[] = {
+ {"cmdItemCreate", dap_chain_node_cli_cmd_item_create_py, METH_VARARGS, ""},
+ {"setReplyText", dap_chain_node_cli_set_reply_text_py, METH_VARARGS, ""},
+ {"getByAlias", dap_chain_node_addr_get_by_alias_py, METH_VARARGS | METH_STATIC, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNodeCliObject_DapChainNodeCliObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Chain.Node.cli", /* tp_name */
+ sizeof(PyDapChainNodeCliObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net node cli object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ DapChainNodeCliMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ DapChainNodeCliObject_new, /* tp_new */
+};
+
+char **PyListToString(PyObject *list);
+PyObject *stringToPyList(char **list);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_WRAPPING_DAP_CHAIN_NET_NODE_CLI_
diff --git a/include/wrapping_dap_chain_net_node_client.h b/include/wrapping_dap_chain_net_node_client.h
new file mode 100644
index 0000000000000000000000000000000000000000..c940a7a4a9083d0814b5a80225642775a0d78efa
--- /dev/null
+++ b/include/wrapping_dap_chain_net_node_client.h
@@ -0,0 +1,85 @@
+#ifndef _WRAPPING_DAP_CHAIN_NODE_CLIENT_
+#define _WRAPPING_DAP_CHAIN_NODE_CLIENT_
+
+#include <Python.h>
+#include "dap_chain_node_client.h"
+#include "wrapping_dap_chain_net_node_info.h"
+#include "libdap_client_python.h"
+#include "wrapping_dap_client_stage.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct PyDapChainNodeClient{
+ PyObject_HEAD
+ dap_chain_node_client_t *node_client;
+}PyDapChainNodeClientObject;
+
+int dap_chain_node_client_init_py(void);
+void dap_chain_node_client_deinit_py(void);
+
+PyObject *dap_chain_client_connect_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_client_connect_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_client_close_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_client_send_ch_pkt_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_client_wait_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_client_set_callbacks_py(PyObject *self, PyObject *args);
+
+static PyMethodDef DapChainNodeClientMethods[] = {
+ {"clientConnect", dap_chain_client_connect_py, METH_VARARGS | METH_STATIC, ""},
+ {"nodeClientConnect", (PyCFunction)dap_chain_node_client_connect_py, METH_VARARGS | METH_STATIC, ""},
+ {"close", (PyCFunction)dap_chain_node_client_close_py, METH_VARARGS, ""},
+ {"sendChPkt", (PyCFunction)dap_chain_node_client_send_ch_pkt_py, METH_VARARGS, ""},
+ {"wait", (PyCFunction)dap_chain_node_client_wait_py, METH_VARARGS, ""},
+ {"setCallbacks", (PyCFunction)dap_chain_node_client_set_callbacks_py, METH_VARARGS | METH_STATIC, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNodeClientObject_DapChainNodeClientObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Chain.Node.Client", /* tp_name */
+ sizeof(PyDapChainNodeClientObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net node client object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ DapChainNodeClientMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_WRAPPING_DAP_CHAIN_NODE_CLIENT_
diff --git a/include/wrapping_dap_chain_net_node_info.h b/include/wrapping_dap_chain_net_node_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..4caec25f837f3ab0f1f4fd61c4e3a4731e9f775f
--- /dev/null
+++ b/include/wrapping_dap_chain_net_node_info.h
@@ -0,0 +1,72 @@
+#ifndef _WRAPPING_DAP_CHAIN_NODE_INFO
+#define _WRAPPING_DAP_CHAIN_NODE_INFO
+#include <Python.h>
+#include "dap_chain_node.h"
+#include "libdap_chain_net_python.h"
+#include "wrapping_dap_chain_common_objects.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyDapChainNodeInfo{
+ PyObject_HEAD
+ dap_chain_node_info_t *node_info;
+}PyDapChainNodeInfoObject;
+
+PyObject *dap_chain_node_info_save_py(PyObject *self, PyObject *args);
+PyObject *dap_chain_node_info_read_py(PyObject *self, PyObject *args);
+
+static PyMethodDef DapChainNetNodeInfoMethods[] = {
+ {"save", dap_chain_node_info_save_py, METH_VARARGS, ""},
+ {"read", dap_chain_node_info_read_py, METH_VARARGS | METH_STATIC, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNodeInfoObject_DapChainNodeInfoObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Chain.Node.Info", /* tp_name */
+ sizeof(PyDapChainNodeInfoObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net node info object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ DapChainNetNodeInfoMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_WRAPPING_DAP_CHAIN_NODE_INFO
diff --git a/include/wrapping_dap_chain_net_state.h b/include/wrapping_dap_chain_net_state.h
new file mode 100644
index 0000000000000000000000000000000000000000..880a4f51640720bc6159560183740ad046955323
--- /dev/null
+++ b/include/wrapping_dap_chain_net_state.h
@@ -0,0 +1,85 @@
+#ifndef _WRAPPING_DAP_CHAIN_NET_STATE_
+#define _WRAPPING_DAP_CHAIN_NET_STATE_
+#include <Python.h>
+#include "dap_chain_net.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+typedef struct PyDapChainNetState{
+ PyObject_HEAD
+ dap_chain_net_state_t state;
+}PyDapChainNetStateObject;
+
+PyObject *NET_STATE_OFFLINE_PY(void);
+PyObject *NET_STATE_LINKS_PREPARE_PY(void);
+PyObject *NET_STATE_LINKS_CONNECTING_PY(void);
+PyObject *NET_STATE_LINKS_ESTABLISHED_PY(void);
+PyObject *NET_STATE_ADDR_REQUEST_PY(void); // Waiting for address assign
+PyObject *NET_STATE_ONLINE_PY(void);
+PyObject *NET_STATE_SYNC_GDB_PY(void);
+PyObject *NET_STATE_SYNC_CHAINS_PY(void);
+
+static PyMethodDef PyDapChainNetStateMethods[] = {
+ {"NET_STATE_OFFLINE", (PyCFunction)NET_STATE_OFFLINE_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_LINKS_PREPARE", (PyCFunction)NET_STATE_LINKS_PREPARE_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_LINKS_CONNECTING", (PyCFunction)NET_STATE_LINKS_CONNECTING_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_LINKS_ESTABLISHED", (PyCFunction)NET_STATE_LINKS_ESTABLISHED_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_ADDR_REQUEST", (PyCFunction)NET_STATE_ADDR_REQUEST_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_SYNC_GDB", (PyCFunction)NET_STATE_SYNC_GDB_PY, METH_NOARGS | METH_STATIC, ""},
+ {"NET_STATE_SYNC_CHAINS", (PyCFunction)NET_STATE_SYNC_CHAINS_PY, METH_NOARGS | METH_STATIC, ""},
+ /*{"csAdd", (PyCFunction)dap_chain_cs_add_py, METH_VARARGS, ""},
+ {"csCreate", (PyCFunction)dap_chain_cs_create_py, METH_VARARGS, ""},
+ {"classAdd", (PyCFunction)dap_chain_class_add_py, METH_VARARGS, ""},
+ {"classCreate", (PyCFunction)dap_chain_class_create_py, METH_VARARGS, ""},*/
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject DapChainNetStateObject_DapChainNetStateObjectType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.ChainNetState", /* tp_name */
+ sizeof(PyDapChainNetStateObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* 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 */
+ "Chain net staties object", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ PyDapChainNetStateMethods, /* 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, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _WRAPPING_DAP_CHAIN_NET_STATE_
diff --git a/libdap b/libdap
new file mode 160000
index 0000000000000000000000000000000000000000..ba3e1eed7b6e76393c035986fe27c8e49cafc2d9
--- /dev/null
+++ b/libdap
@@ -0,0 +1 @@
+Subproject commit ba3e1eed7b6e76393c035986fe27c8e49cafc2d9
diff --git a/libdap-chain b/libdap-chain
new file mode 160000
index 0000000000000000000000000000000000000000..008b7a65045c6b20b7daf743b112ba16aa0172a9
--- /dev/null
+++ b/libdap-chain
@@ -0,0 +1 @@
+Subproject commit 008b7a65045c6b20b7daf743b112ba16aa0172a9
diff --git a/libdap-chain-crypto b/libdap-chain-crypto
new file mode 160000
index 0000000000000000000000000000000000000000..1a7f57339041f51675a766fb7848d16c6010ff11
--- /dev/null
+++ b/libdap-chain-crypto
@@ -0,0 +1 @@
+Subproject commit 1a7f57339041f51675a766fb7848d16c6010ff11
diff --git a/libdap-chain-gdb b/libdap-chain-gdb
new file mode 160000
index 0000000000000000000000000000000000000000..eb4cec1af570b411ba19dc5b03589dd02be9db09
--- /dev/null
+++ b/libdap-chain-gdb
@@ -0,0 +1 @@
+Subproject commit eb4cec1af570b411ba19dc5b03589dd02be9db09
diff --git a/libdap-chain-global-db b/libdap-chain-global-db
new file mode 160000
index 0000000000000000000000000000000000000000..1419a98d73dcc1927f59645e97b23adb813b47aa
--- /dev/null
+++ b/libdap-chain-global-db
@@ -0,0 +1 @@
+Subproject commit 1419a98d73dcc1927f59645e97b23adb813b47aa
diff --git a/libdap-chain-mempool b/libdap-chain-mempool
new file mode 160000
index 0000000000000000000000000000000000000000..6a91d6b8a821b5e3ad470bf75452cfaeab1899a0
--- /dev/null
+++ b/libdap-chain-mempool
@@ -0,0 +1 @@
+Subproject commit 6a91d6b8a821b5e3ad470bf75452cfaeab1899a0
diff --git a/libdap-chain-net b/libdap-chain-net
new file mode 160000
index 0000000000000000000000000000000000000000..37eb1ddca764eb558224371801967b4d96b93965
--- /dev/null
+++ b/libdap-chain-net
@@ -0,0 +1 @@
+Subproject commit 37eb1ddca764eb558224371801967b4d96b93965
diff --git a/libdap-chain-net-srv b/libdap-chain-net-srv
new file mode 160000
index 0000000000000000000000000000000000000000..f15809e9abf5d54642cc84dae4fe73666eda5a38
--- /dev/null
+++ b/libdap-chain-net-srv
@@ -0,0 +1 @@
+Subproject commit f15809e9abf5d54642cc84dae4fe73666eda5a38
diff --git a/libdap-chain-net-srv-vpn b/libdap-chain-net-srv-vpn
new file mode 160000
index 0000000000000000000000000000000000000000..01afd8dc04708458fb742c36a0a5b49e01dd6716
--- /dev/null
+++ b/libdap-chain-net-srv-vpn
@@ -0,0 +1 @@
+Subproject commit 01afd8dc04708458fb742c36a0a5b49e01dd6716
diff --git a/libdap-chain-python b/libdap-chain-python
new file mode 160000
index 0000000000000000000000000000000000000000..4bbc01ce9a5878c155a67e7cd36535419e360a54
--- /dev/null
+++ b/libdap-chain-python
@@ -0,0 +1 @@
+Subproject commit 4bbc01ce9a5878c155a67e7cd36535419e360a54
diff --git a/libdap-chain-wallet b/libdap-chain-wallet
new file mode 160000
index 0000000000000000000000000000000000000000..93c2043d3c74fc6dceba75d2d9862317d9ba6990
--- /dev/null
+++ b/libdap-chain-wallet
@@ -0,0 +1 @@
+Subproject commit 93c2043d3c74fc6dceba75d2d9862317d9ba6990
diff --git a/libdap-client b/libdap-client
new file mode 160000
index 0000000000000000000000000000000000000000..ca5ac6ff584ba8220aba04ffa8be1fc6bc0a5d57
--- /dev/null
+++ b/libdap-client
@@ -0,0 +1 @@
+Subproject commit ca5ac6ff584ba8220aba04ffa8be1fc6bc0a5d57
diff --git a/libdap-client-python b/libdap-client-python
new file mode 160000
index 0000000000000000000000000000000000000000..b1918f7c8378d1e03e2915565c3764c4a803b2b6
--- /dev/null
+++ b/libdap-client-python
@@ -0,0 +1 @@
+Subproject commit b1918f7c8378d1e03e2915565c3764c4a803b2b6
diff --git a/libdap-crypto b/libdap-crypto
new file mode 160000
index 0000000000000000000000000000000000000000..17f8218833f473d2c954113617ae63cb5dc9400f
--- /dev/null
+++ b/libdap-crypto
@@ -0,0 +1 @@
+Subproject commit 17f8218833f473d2c954113617ae63cb5dc9400f
diff --git a/libdap-crypto-python b/libdap-crypto-python
new file mode 160000
index 0000000000000000000000000000000000000000..e0fef50bbe630c2835020fbebf3bcdfe064255a8
--- /dev/null
+++ b/libdap-crypto-python
@@ -0,0 +1 @@
+Subproject commit e0fef50bbe630c2835020fbebf3bcdfe064255a8
diff --git a/libdap-python b/libdap-python
new file mode 160000
index 0000000000000000000000000000000000000000..4a15aca686aa56313f8ef8157c7d0aba7c9d7154
--- /dev/null
+++ b/libdap-python
@@ -0,0 +1 @@
+Subproject commit 4a15aca686aa56313f8ef8157c7d0aba7c9d7154
diff --git a/libdap-server b/libdap-server
new file mode 160000
index 0000000000000000000000000000000000000000..4a84966dbafc3ae0d207c21ced4c5a41e25872dd
--- /dev/null
+++ b/libdap-server
@@ -0,0 +1 @@
+Subproject commit 4a84966dbafc3ae0d207c21ced4c5a41e25872dd
diff --git a/libdap-server-core b/libdap-server-core
new file mode 160000
index 0000000000000000000000000000000000000000..1d74e9451906fbaa752c04242d266fdd84f944d3
--- /dev/null
+++ b/libdap-server-core
@@ -0,0 +1 @@
+Subproject commit 1d74e9451906fbaa752c04242d266fdd84f944d3
diff --git a/libdap-server-udp b/libdap-server-udp
new file mode 160000
index 0000000000000000000000000000000000000000..2aaaad5981206379c1a7e7c8af3dc3d6aa26e2e7
--- /dev/null
+++ b/libdap-server-udp
@@ -0,0 +1 @@
+Subproject commit 2aaaad5981206379c1a7e7c8af3dc3d6aa26e2e7
diff --git a/libdap-stream b/libdap-stream
new file mode 160000
index 0000000000000000000000000000000000000000..a7ee4c8a206e6e5bb1290ba83b00abe0052f2183
--- /dev/null
+++ b/libdap-stream
@@ -0,0 +1 @@
+Subproject commit a7ee4c8a206e6e5bb1290ba83b00abe0052f2183
diff --git a/libdap-stream-ch b/libdap-stream-ch
new file mode 160000
index 0000000000000000000000000000000000000000..c07c5e4a379f8d66052306c8d40db334d0ff6500
--- /dev/null
+++ b/libdap-stream-ch
@@ -0,0 +1 @@
+Subproject commit c07c5e4a379f8d66052306c8d40db334d0ff6500
diff --git a/libdap-stream-ch-chain b/libdap-stream-ch-chain
new file mode 160000
index 0000000000000000000000000000000000000000..2beb1453e0ad96e8e62357867076a316b5af9895
--- /dev/null
+++ b/libdap-stream-ch-chain
@@ -0,0 +1 @@
+Subproject commit 2beb1453e0ad96e8e62357867076a316b5af9895
diff --git a/libdap-stream-ch-chain-net b/libdap-stream-ch-chain-net
new file mode 160000
index 0000000000000000000000000000000000000000..71ae6ccd1c2ec6d12916835c10b74df0e6ad9dd5
--- /dev/null
+++ b/libdap-stream-ch-chain-net
@@ -0,0 +1 @@
+Subproject commit 71ae6ccd1c2ec6d12916835c10b74df0e6ad9dd5
diff --git a/src/libdap_chain_net_python.c b/src/libdap_chain_net_python.c
new file mode 100644
index 0000000000000000000000000000000000000000..60235584b81d1d42de412598697eeacc147e96bc
--- /dev/null
+++ b/src/libdap_chain_net_python.c
@@ -0,0 +1,138 @@
+#include "libdap_chain_net_python.h"
+
+int dap_chain_net_init_py(void){
+ int res = dap_chain_net_init();
+ return res;
+}
+void dap_chain_net_deinit_py(void){
+ dap_chain_net_deinit();
+}
+
+PyObject *dap_chain_net_load_all_py(PyObject *self, PyObject *args){
+ dap_chain_net_load_all();
+ return PyLong_FromLong(0);
+}
+PyObject *dap_chain_net_state_go_to_py(PyObject *self, PyObject *args){
+ PyObject *obj_net_state;
+ if (!PyArg_ParseTuple(args, "O", &obj_net_state))
+ return NULL;
+ int res = dap_chain_net_state_go_to(((PyDapChainNetObject*)self)->chain_net, ((PyDapChainNetStateObject*)obj_net_state)->state);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_start_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_start(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_stop_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_stop(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_links_establish_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_links_establish(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_sync_chains_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_sync_chains(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_sync_gdb_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_sync_gdb(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_net_sync_all_py(PyObject *self, PyObject *args){
+ int res = dap_chain_net_sync_all(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(res);
+}
+
+PyObject *dap_chain_net_proc_datapool_py(PyObject *self, PyObject *args){
+ dap_chain_net_proc_datapool(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_chain_net_by_name_py(PyObject *self, PyObject *args){
+ const char *a_name;
+ if (!PyArg_ParseTuple(args, "s", &a_name))
+ return NULL;
+ PyObject *obj_chain_net = _PyObject_New(&DapChainNetObject_DapChainNetObjectType);
+ ((PyDapChainNetObject*)obj_chain_net)->chain_net = dap_chain_net_by_name(a_name);
+ return Py_BuildValue("O", obj_chain_net);
+}
+PyObject *dap_chain_net_by_id_py(PyObject *self, PyObject *args){
+ PyObject *obj_net_id;
+ if (!PyArg_ParseTuple(args, "O", &obj_net_id))
+ return NULL;
+ PyObject *obj_net = _PyObject_New(&DapChainNetObject_DapChainNetObjectType);
+ ((PyDapChainNetObject*)obj_net)->chain_net = dap_chain_net_by_id(((PyDapChainNetIdObject*)obj_net_id)->net_id);
+ return Py_BuildValue("O", obj_net);
+}
+PyObject *dap_chain_net_id_by_name_py(PyObject *self, PyObject *args){
+ const char *name;
+ if (!PyArg_ParseTuple(args, "s", &name))
+ return NULL;
+ PyObject *obj_net_id = _PyObject_New(&DapChainNetIdObject_DapChainNetIdObjectType);
+ ((PyDapChainNetIdObject*)obj_net_id)->net_id = dap_chain_net_id_by_name(name);
+ return Py_BuildValue("O", obj_net_id);
+}
+PyObject *dap_chain_ledger_by_net_name_py(PyObject *self, PyObject *args){
+ const char *net_name;
+ if (!PyArg_ParseTuple(args, "s", &net_name))
+ return NULL;
+ PyObject *obj_ledger = _PyObject_New(&DapChainLedger_DapChainLedgerType);
+ ((PyDapChainLedgerObject*)obj_ledger)->ledger = dap_chain_ledger_by_net_name(net_name);
+ return Py_BuildValue("O", obj_ledger);
+}
+
+PyObject *dap_chain_net_get_chain_by_name_py(PyObject *self, PyObject *args){
+ const char* chain_name;
+ if (!PyArg_ParseTuple(args, "s", &chain_name))
+ return NULL;
+ PyObject *obj_chain = _PyObject_New(&dapChainObject_dapChainType);
+ ((PyDapChainObject*)obj_chain)->chain_t = dap_chain_net_get_chain_by_name(((PyDapChainNetObject*)self)->chain_net, chain_name);
+ return Py_BuildValue("O", obj_chain);
+}
+
+PyObject *dap_chain_net_get_cur_addr_py(PyObject *self, PyObject *args){
+ PyObject *obj_node_addr = _PyObject_New(&DapChainNodeAddrObject_DapChainNodeAddrObjectType);
+ ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr = dap_chain_net_get_cur_addr(((PyDapChainNetObject*)self)->chain_net);
+ return Py_BuildValue("O", obj_node_addr);
+}
+PyObject *dap_chain_net_get_cur_cell_py(PyObject *self, PyObject *args){
+ PyObject *obj_cell_id = _PyObject_New(&DapChainNodeAddrObject_DapChainNodeAddrObjectType);
+ ((PyDapChainCellIdObject*)obj_cell_id)->id = *(dap_chain_net_get_cur_cell(((PyDapChainNetObject*)self)->chain_net));
+ return Py_BuildValue("O", obj_cell_id);
+}
+PyObject *dap_chain_net_get_cur_addr_int_py(PyObject *self, PyObject *args){
+ uint64_t res = dap_chain_net_get_cur_addr_int(((PyDapChainNetObject*)self)->chain_net);
+ return PyLong_FromUnsignedLongLong(res);
+}
+
+PyObject *dap_chain_net_get_gdb_group_mempool_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain;
+ if (!PyArg_ParseTuple(args, "O", &obj_chain))
+ return NULL;
+ char *res = dap_chain_net_get_gdb_group_mempool(((PyDapChainObject*)obj_chain)->chain_t);
+ return Py_BuildValue("s", res);
+}
+PyObject *dap_chain_net_get_gdb_group_mempool_by_chain_type_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_type;
+ if (!PyArg_ParseTuple(args, "O", &obj_chain_type))
+ return NULL;
+ char *res = dap_chain_net_get_gdb_group_mempool_by_chain_type(((PyDapChainNetObject*)self)->chain_net,
+ ((PyChainTypeObject*)obj_chain_type)->chain_type);
+ return Py_BuildValue("s", res);
+
+}
+PyObject *dap_chain_net_links_connect_py(PyObject *self, PyObject *args){
+ dap_chain_net_links_connect(((PyDapChainNetObject*)self)->chain_net);
+ PyLong_FromLong(0);
+}
+PyObject *dap_chain_net_get_chain_by_chain_type_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_type;
+ if(!PyArg_ParseTuple(args, "O", &obj_chain_type))
+ return NULL;
+ PyObject *obj_chain = _PyObject_New(&dapChainObject_dapChainType);
+ ((PyDapChainObject*)obj_chain)->chain_t = dap_chain_net_get_chain_by_chain_type(
+ ((PyDapChainNetObject*)self)->chain_net,
+ ((PyChainTypeObject*)obj_chain_type)->chain_type);
+ return Py_BuildValue("O", obj_chain);
+}
diff --git a/src/wrapping_dap_chain_net_node.c b/src/wrapping_dap_chain_net_node.c
new file mode 100644
index 0000000000000000000000000000000000000000..8f7eeaa083e2da6c3025af87cc181a01172edc45
--- /dev/null
+++ b/src/wrapping_dap_chain_net_node.c
@@ -0,0 +1,55 @@
+#include "wrapping_dap_chain_net_node.h"
+
+PyObject *dap_chain_node_gen_addr_py(PyObject *self, PyObject *args){
+ PyObject *obj_net;
+ PyObject *obj_cell_id;
+ if (!PyArg_ParseTuple(args, "O|O", &obj_net, &obj_cell_id))
+ return NULL;
+ PyObject *obj_node_addr = _PyObject_New(&DapChainNodeAddrObject_DapChainNodeAddrObjectType);
+ ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr = dap_chain_node_gen_addr(((PyDapChainNetObject*)obj_net)->chain_net, &(((PyDapChainCellIdObject*)obj_cell_id)->id));
+ return Py_BuildValue("O", obj_node_addr);
+}
+PyObject *dap_chain_node_check_addr_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_net;
+ PyObject *obj_node_addr;
+ PyObject *obj_cell_id;
+ if (!PyArg_ParseTuple(args, "O|O|O", &obj_chain_net, &obj_node_addr, &obj_cell_id))
+ return NULL;
+ bool ret = dap_chain_node_check_addr(((PyDapChainNetObject*)obj_chain_net)->chain_net, ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr, &(((PyDapChainCellIdObject*)obj_cell_id)->id));
+ if (ret)
+ return Py_BuildValue("O", Py_True);
+ else
+ return Py_BuildValue("O", Py_False);
+}
+PyObject *dap_chain_node_alias_find_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_net;
+ const char *alias;
+ if (!PyArg_ParseTuple(args, "O|s", &obj_chain_net, &alias))
+ return NULL;
+ PyObject *obj_node_addr = _PyObject_New(&DapChainNodeAddrObject_DapChainNodeAddrObjectType);
+ ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr = dap_chain_node_alias_find(((PyDapChainNetObject*)obj_node_addr)->chain_net, alias);
+ return Py_BuildValue("O", &obj_node_addr);
+}
+PyObject *dap_chain_node_alias_register_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_net;
+ const char *alias;
+ PyObject *obj_node_addr;
+ if (!PyArg_ParseTuple(args, "O|s|O", &obj_chain_net, &alias, &obj_node_addr))
+ return NULL;
+ bool ret = dap_chain_node_alias_register(((PyDapChainNetObject*)obj_chain_net)->chain_net, alias, ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr);
+ if (ret)
+ return Py_BuildValue("O", Py_True);
+ else
+ return Py_BuildValue("O", Py_False);
+}
+PyObject *dap_chain_node_alias_delete_py(PyObject *self, PyObject *args){
+ PyObject *obj_chain_net;
+ const char *alias;
+ if (!PyArg_ParseTuple(args, "O|s", &obj_chain_net, &alias))
+ return NULL;
+ bool ret = dap_chain_node_alias_delete(((PyDapChainNetObject*)obj_chain_net)->chain_net, alias);
+ if (ret)
+ return Py_BuildValue("O", Py_True);
+ else
+ return Py_BuildValue("O", Py_False);
+}
diff --git a/src/wrapping_dap_chain_net_node_cli.c b/src/wrapping_dap_chain_net_node_cli.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab3d31f502c5c24819fd8d9b678c6292027ed2c1
--- /dev/null
+++ b/src/wrapping_dap_chain_net_node_cli.c
@@ -0,0 +1,89 @@
+#include "wrapping_dap_chain_net_node_cli.h"
+
+int dap_chain_node_cli_init_py(dap_config_t *g_config){
+ dap_chain_node_cli_init(g_config);
+}
+void dap_chain_node_cli_delete_py(void){
+ dap_chain_node_cli_delete();
+}
+
+static int wrapping_cmdfunc(int argc, char **argv, char **str_reply){
+ PyObject *arglist;
+ PyObject *result;
+ PyObject *obj_argv = stringToPyList(argv);
+ PyObject *obj_str_reply = stringToPyList(str_reply);
+ arglist = Py_BuildValue("i|O|O", argc, obj_argv, obj_str_reply);
+ result = PyObject_CallObject(binded_object_cmdfunc, arglist);
+ Py_DECREF(arglist);
+ Py_DECREF(obj_argv);
+ Py_DECREF(obj_str_reply);
+ int r = -1;
+ if (PyLong_Check(result)){
+ r = (int)PyLong_AsLong(result);
+ }
+ Py_DECREF(result);
+ return r;
+}
+
+PyObject *DapChainNodeCliObject_new(PyTypeObject *type_object, PyObject *args, PyObject *kwds){
+ PyDapChainNodeCliObject *obj = (PyDapChainNodeCliObject*)PyType_GenericNew(type_object, args, kwds);
+ obj->func = wrapping_cmdfunc;
+ return (PyObject *)obj;
+}
+
+PyObject *dap_chain_node_cli_cmd_item_create_py(PyObject *self, PyObject *args){
+ const char *name, *doc, *doc_ex;
+ PyObject *obj_cmdfunc;
+ if (!PyArg_ParseTuple(args, "s|O:set_callback|s|s", &name, &obj_cmdfunc, &doc, &doc_ex)){
+ return NULL;
+ } else {
+ if (!PyCallable_Check(obj_cmdfunc)){
+ PyErr_SetString(PyExc_TypeError, "parameter must be callable");
+ return NULL;
+ }
+ }
+ Py_XINCREF(obj_cmdfunc);
+ Py_XDECREF(binded_object_cmdfunc);
+ binded_object_cmdfunc = obj_cmdfunc;
+ dap_chain_node_cli_cmd_item_create(name, ((PyDapChainNodeCliObject*)obj_cmdfunc)->func, doc, doc_ex);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_chain_node_cli_set_reply_text_py(PyObject *self, PyObject *args){
+ PyObject *obj_str_reply_list;
+ const char *str_list;
+ if (!PyArg_ParseTuple(args, "O|O", &obj_str_reply_list))
+ return NULL;
+ char **str_reply_list = PyListToString(obj_str_reply_list);
+ dap_chain_node_cli_set_reply_text(str_reply_list, str_list);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_chain_node_addr_get_by_alias_py(PyObject *self, PyObject *args){
+ PyObject *chain_net;
+ const char *alias;
+ if (!PyArg_ParseTuple(args, "O|s", &chain_net, &alias))
+ return NULL;
+ PyObject *obj_node_addr = _PyObject_New(&DapChainNodeAddrObject_DapChainNodeAddrObjectType);
+ ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr = dap_chain_node_addr_get_by_alias(((PyDapChainNetObject*)chain_net)->chain_net, alias);
+ return Py_BuildValue("O", obj_node_addr);
+}
+
+char **PyListToString(PyObject *list){
+ Py_ssize_t size = PyList_Size(list);
+ char **res = calloc(sizeof(char**), (size_t)size);
+ for (Py_ssize_t i=0; i < size;i++ ){
+ char *data = PyBytes_AsString(PyList_GetItem(list, i));
+ res[(size_t)i] = data;
+ }
+ return res;
+}
+PyObject *stringToPyList(char **list){
+ size_t size = sizeof(list) / sizeof(list[0]);
+ PyObject *obj = PyList_New((Py_ssize_t)size);
+ for (size_t i=0; i < size; i++){
+ PyObject *data = PyBytes_FromString(list[i]);
+ PyList_Append(obj, data);
+ }
+ return obj;
+}
diff --git a/src/wrapping_dap_chain_net_node_client.c b/src/wrapping_dap_chain_net_node_client.c
new file mode 100644
index 0000000000000000000000000000000000000000..4a2e5b08ed538a426b61e6362aee6f5f15971b17
--- /dev/null
+++ b/src/wrapping_dap_chain_net_node_client.c
@@ -0,0 +1,66 @@
+#include "wrapping_dap_chain_net_node_client.h"
+
+int dap_chain_node_client_init_py(void){
+ return dap_chain_node_client_init();
+}
+void dap_chain_node_client_deinit_py(void){
+ dap_chain_node_client_deinit();
+}
+
+PyObject *dap_chain_client_connect_py(PyObject *self, PyObject *args){
+ PyObject *obj_node_info;
+ PyObject *obj_client_stage;
+ const char *active_channels;
+ if (!PyArg_ParseTuple(args, "O|O|s", &obj_node_info, &obj_client_stage, &active_channels))
+ return NULL;
+ PyObject *obj_node_client = _PyObject_New(&DapChainNodeClientObject_DapChainNodeClientObjectType);
+ ((PyDapChainNodeClientObject*)obj_node_client)->node_client =dap_chain_client_connect(
+ ((PyDapChainNodeInfoObject*)obj_node_info)->node_info,
+ ((PyDapClientStageObject*)obj_client_stage)->stage, active_channels);
+ return Py_BuildValue("O", obj_node_client);
+}
+PyObject *dap_chain_node_client_connect_py(PyObject *self, PyObject *args){
+ if (self != NULL){
+ PyErr_SetString(PyExc_SyntaxWarning, "This is method called statically");
+ return NULL;
+ }
+ PyObject *obj_node_info;
+ if (!PyArg_ParseTuple(args, "O", &obj_node_info))
+ return NULL;
+ PyObject *obj_node_client = _PyObject_New(&DapChainNodeClientObject_DapChainNodeClientObjectType);
+ ((PyDapChainNodeClientObject*)obj_node_client)->node_client = dap_chain_node_client_connect(((PyDapChainNodeInfoObject*)obj_node_info)->node_info);
+ return Py_BuildValue("O", obj_node_client);
+}
+PyObject *dap_chain_node_client_close_py(PyObject *self, PyObject *args){
+ dap_chain_node_client_close(((PyDapChainNodeClientObject*)self)->node_client);
+ return PyLong_FromLong(0);
+}
+PyObject *dap_chain_node_client_send_ch_pkt_py(PyObject *self, PyObject *args){
+ uint8_t ch_id;
+ uint8_t type;
+ PyObject *obj_buf;
+ void *buf;
+ size_t buf_size;
+ if (!PyArg_ParseTuple(args, "b|b|O", &ch_id, &type, &obj_buf))
+ return NULL;
+ buf = PyBytes_AsString(obj_buf);
+ buf_size = (size_t)PyBytes_Size(buf);
+ int res = dap_chain_node_client_send_ch_pkt(((PyDapChainNodeClientObject*)self)->node_client, ch_id, type, buf, buf_size);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_node_client_wait_py(PyObject *self, PyObject *args){
+ int waited_state;
+ int timeout_ms;
+ if (!PyArg_ParseTuple(args, "i|i", &waited_state, &timeout_ms))
+ return NULL;
+ int res = dap_chain_node_client_wait(((PyDapChainNodeClientObject*)self)->node_client, waited_state, timeout_ms);
+ return PyLong_FromLong(res);
+}
+PyObject *dap_chain_node_client_set_callbacks_py(PyObject *self, PyObject *args){
+ PyObject *obj_dap_client;
+ uint8_t ch_id;
+ if (!PyArg_ParseTuple(args, "O|b", &obj_dap_client, &ch_id))
+ return NULL;
+ int res = dap_chain_node_client_set_callbacks(((PyDapClientObject*)obj_dap_client)->client, ch_id);
+ return PyLong_FromLong(res);
+}
diff --git a/src/wrapping_dap_chain_net_node_info.c b/src/wrapping_dap_chain_net_node_info.c
new file mode 100644
index 0000000000000000000000000000000000000000..36e1915a3f1ca5d2178d0efe0ee7a45f5b521203
--- /dev/null
+++ b/src/wrapping_dap_chain_net_node_info.c
@@ -0,0 +1,19 @@
+#include "wrapping_dap_chain_net_node_info.h"
+
+PyObject *dap_chain_node_info_save_py(PyObject *self, PyObject *args){
+ PyObject *obj_net;
+ if (!PyArg_ParseTuple(args, "O", &obj_net))
+ return NULL;
+ int res = dap_chain_node_info_save(((PyDapChainNetObject*)obj_net)->chain_net, ((PyDapChainNodeInfoObject*)self)->node_info);
+ return PyLong_FromLong(res);
+}
+
+PyObject *dap_chain_node_info_read_py(PyObject *self, PyObject *args){
+ PyObject *obj_net;
+ PyObject *obj_node_addr;
+ if (!PyArg_ParseTuple(args, "O|O", &obj_net, &obj_node_addr))
+ return NULL;
+ PyObject *obj_node_info = _PyObject_New(&DapChainNodeInfoObject_DapChainNodeInfoObjectType);
+ ((PyDapChainNodeInfoObject*)obj_node_info)->node_info = dap_chain_node_info_read(((PyDapChainNetObject*)obj_net)->chain_net, ((PyDapChainNodeAddrObject*)obj_node_addr)->node_addr);
+ return Py_BuildValue("O", &obj_node_info);
+}
diff --git a/src/wrapping_dap_chain_net_state.c b/src/wrapping_dap_chain_net_state.c
new file mode 100644
index 0000000000000000000000000000000000000000..1042393fe4411d0da97437332de294f709eb26b4
--- /dev/null
+++ b/src/wrapping_dap_chain_net_state.c
@@ -0,0 +1,42 @@
+#include "wrapping_dap_chain_net_state.h"
+
+PyObject *NET_STATE_OFFLINE_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_OFFLINE;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_LINKS_PREPARE_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_LINKS_PREPARE;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_LINKS_CONNECTING_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_LINKS_CONNECTING;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_LINKS_ESTABLISHED_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_LINKS_ESTABLISHED;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_ADDR_REQUEST_PY(void){ // Waiting for address assign
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_ADDR_REQUEST;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_ONLINE_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_ONLINE;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_SYNC_GDB_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_SYNC_GDB;
+ return Py_BuildValue("O", obj);
+}
+PyObject *NET_STATE_SYNC_CHAINS_PY(void){
+ PyObject *obj = _PyObject_New(&DapChainNetStateObject_DapChainNetStateObjectType);
+ ((PyDapChainNetStateObject*)obj)->state = NET_STATE_SYNC_CHAINS;
+ return Py_BuildValue("O", obj);
+}