directory = 'chain/config/'
    filename = 'node_vector.atm'
    if not os.path.exists(directory):
        os.makedirs(directory)
    # make genesis node vector number
    atom_vector_data[1] = {
        'node': 1,
        'adress': node_adr,
        'ipport': '192.168.0.100',
        'active': True,
        }
    atom_vector_data[2] = {
        'next_key' : randint(1, 1000000)
    }
    node.write_dict_file(atom_vector_data,directory,filename)  # метод который записывает dict в файл в pickle формате

@app.route('/zapros', methods=['GET', 'POST'])
def zapros():
    # make geniesis block
    zapros_adr = request.args.get('zapros_adr', 0, type=str)
    base_node = request.args.get('base_node', 0, type=str)
    ipport = request.args.get('ipport', 0, type=str)
    result = node.try_connect_to_network(zapros_adr,ipport,base_node)
    return jsonify(result=result)

def try_connect_to_network(self,adr,ipport,base_node):
        context = zmq.Context(1)
        client = context.socket(zmq.REQ)
        SERVER_ENDPOINT = 'tcp://'+base_node
        client.connect(SERVER_ENDPOINT)
        poll = zmq.Poller()
        poll.register(client, zmq.POLLIN)
        REQUEST_TIMEOUT = 2500
        REQUEST_RETRIES = 3
        retries_left = REQUEST_RETRIES

        while retries_left:
            data_send = {'addmeplz': '1','adr': adr, 'ip': ipport}
            data_send = str(data_send).encode()
            request = data_send
            print("I: Пересылаю (%s)" % request)
            client.send(request)
            data = ''
            expect_reply = True
            while expect_reply:
                socks = dict(poll.poll(REQUEST_TIMEOUT))
                if socks.get(client) == zmq.POLLIN:
                    reply = client.recv()
                    reply = eval(reply.decode())
                    print(reply['send_hash'])
                    print(self.thishash(request))
                    if not reply:
                        data = 'break, not reply recive'
                        break
                    if reply['send_hash'].decode() == self.thishash(request):
                        print("I: Server replied (%s)" % reply)
                        retries_left = 0
                        data = 'answer: ' + reply['msg']
                        expect_reply = False
                    else:
                        print("E: Malformed reply from server: %s" % reply)

                else:
                    data = 'no response'
                    print("W: No response from server, retrying…")
                    # Socket is confused. Close and remove it.
                    client.setsockopt(zmq.LINGER, 0)
                    client.close()
                    poll.unregister(client)
                    retries_left -= 1
                    if retries_left == 0:
                        print("E: Server seems to be offline, abandoning")
                        break
                    print("I: Reconnecting and resending (%s)" % request)
                    # Create new connection
                    client = context.socket(zmq.REQ)
                    client.connect(SERVER_ENDPOINT)
                    poll.register(client, zmq.POLLIN)
                    client.send(request)
        return str(data)

context = zmq.Context(1)
server = context.socket(zmq.REP)
server.bind("tcp://*:5555")

cycles = 0
while True:
    request_clear = server.recv()
    request = eval(request_clear.decode())
    result_print = 'none'
    if 'addmeplz' in request:
        result = node.add_new_node(request['adr'],request['ip'])
        result_print = result
    send_hash = node.thishash(request_clear).encode()
    send_rep = {
            'send_hash' : send_hash,
            'msg': result
        }
    print(result_print)
    print(str(send_rep).encode())
    server.send(str(send_rep).encode())

   def add_new_node(self,adr,ipport):
        node_vector = self.read_vector_file()  # читай файл
        for key, value in node_vector.items():
            if adr in node_vector[key].values():
                return 'This adr has in vector file, not add'
        dlina = len(node_vector)
        node_vector[dlina+1] = {
            'node': dlina+1,
            'adress': adr,
            'ipport': ipport,
            'active': False
        }
        self.write_dict_file(node_vector,'chain/config/','node_vector.atm')  # обновляем файл
        return 'Add in global vector file'

@app.route('/connect', methods=['GET', 'POST'])
def node_connect():
    msg = request.form.to_dict()
    directory = 'chain/config/'
    filename = 'txpool_swamp.atm'
    node.add_dict_file(msg,directory,filename)  # пишем в mempool
    msg_no_sign = {'send':msg['send'],'from':msg['from'],'count':msg['count'],'adr':msg['adr']}
    rnd_node = node.poh(msg_no_sign,10)
    verify = wallet.verify_sig(msg['from'],msg['sign'],msg_no_sign)
    if verify == True:
        msg_no_sign['sign'] = msg['sign']
        send_to_all = node.send_to_all_node(rnd_node,msg_no_sign)
        get_data = node.load_and_send(msg['adr'],msg['count'],msg['send'],msg['send_komis'])


        return jsonify(get_data), 200
    if verify == False:
        return jsonify('Bad sign'

import pickle
import time
from cl_node import *
from wallet import *
node = Node()  # Создаем объект Node
wallet = Wallet()  # Создаем объект Wallet


import asyncio
def check_tx(msg):
    # there need check tx
    # and add tx to clear leak pool
    path = 'chain/config/'
    filename = 'txpool_leak.atm'
    if not os.path.exists(path):
        os.makedirs(path)
    node.add_dict_file(msg, path, filename)


async def swamp():
    k = 0
    dict = {}
    path = 'chain/config/'
    filename = 'txpool_swamp.atm'
    while True:
        if not os.path.exists(path):
            os.makedirs(path)
        with open(path+filename, 'rb') as f:
            while True:
                try:
                    dict[k] = pickle.load(f)
                    check_tx(dict[k])
                    print(dict[k])
                    k += 1
                except EOFError:
                    open(path+filename, 'w').close()
                    # тут await еще один
                    break                      


async def send_another_node():
    while True:
        print('Try send anoter node')
        await asyncio.sleep(1)


ioloop = asyncio.get_event_loop()
tasks = [ioloop.create_task(swamp()), ioloop.create_task(send_another_node())]
wait_tasks = asyncio.wait(tasks)
ioloop.run_until_complete(wait_tasks)
ioloop.close()