Bitcoin Forum

        
        generate_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
        public_key = generate_key.get_verifying_key() # clear key: <ecdsa.keys.SigningKey object at 0x06521A30>
        public_key = public_key.to_string().hex()
        private_key = binascii.hexlify(generate_key.to_string()).decode() #privat key: 374bc766d11a59a826249fc42f370cee0518e70925c96e73c1848716216d2f64

    
    key = base58.b58encode(bytes.fromhex(key))
    ripemd160 = hashlib.new('ripemd160')
    ripemd160.update(hashlib.sha256(key.encode()).digest())
    key = base58.b58encode(ripemd160.digest())

wallet_file_content = {
            "private_key": private_key,
            "public_key": public_key,            
            "publickey_adress": key}
    

        with open('wallet.pem', 'w') as out:
            for key, val in wallet_file_content.items():
                out.write('{}:{}\n'.format(key, val))

       
    
        ph = PasswordHasher()
        pwd_hash = ph.hash(pwd) # pwd это пароль, который вы вводите в форму на сайте
        return pwd_hash

    
def pass_verify(self,pwd,hash):
        ph = PasswordHasher()
        something = 'pass wrong'
        try:
            val = ph.verify(hash, pwd)
        except:
            return something
        return bool(val)

#!/user/env python3
# -*- coding: utf-8 -*-

import socket
import time
import threading

#
# Ждем сообщения от ноды 1264
#
def server():
    # слушаем и отправляем данные
    s = socket.socket(socket.AF_INET,      # задамем семейство протоколов 'Интернет' (INET)
                          socket.SOCK_STREAM,  # задаем тип передачи данных 'потоковый' (TCP)
                          proto=0)
    host = socket.gethostname()
    print(host)
    port = 1264
    s.bind((host, port))

    s.listen(5)


    while True:
        c, addr = s.accept()
        c.send(b'Answer from node 1, adr: ' + str(addr).encode())
        while True:
            # Пока клиент не отключился, читаем передаваемые
            # им данные и отправляем их обратно
            data = c.recv(1024)
            if not data:
                # Клиент отключился
                break
            else:
                print(data.decode())

#
# Отправляем сообщения ноде на 1265 порту
#
def client():
    while True:
        s_get = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        host = socket.gethostname()
        port = 1265
        while True:
            try:
                s_get.connect((host, port))
                break
            except ConnectionRefusedError:
                time.sleep(10)
                print ('Try connect')

        s_get.sendall(b'Msg from node 1')
        data = s_get.recv(1024)
        s_get.close()
        print('Received', repr(data.decode()))
        time.sleep(10)


if __name__ == '__main__':
    my_thread_server = threading.Thread(target=server, args=())
    my_thread_client = threading.Thread(target=client, args=())
    my_thread_server.start()
    my_thread_client.start()

from __future__ import print_function

from random import randint
import time
import zmq
import sys
from cl_node import *

node = Node()
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())
    if 'wtf' in request:
        print('Work on new transaction')
        print(cycles, ": Normal request (%s)" % str(request))

    if 'addmeplz' in request:
        print('Try add new node')
        node.add_new_node(request['adr'],request['ip'])
        print(cycles, ": Normal request (%s)" % str(request))


    cycles += 1
    # Simulate various problems, after a few cycles
    if cycles > 1000 and randint(0, 1000) == 0:
        print("I: Simulating a crash")
        break
    elif cycles > 1000 and randint(0, 100) == 0:
        print("I: Simulating CPU overload")
        time.sleep(2)

    #time.sleep(1) # Do some heavy work
    send_hash = node.thishash(request_clear).encode()
    print(send_hash)
    server.send(send_hash)

server.close()
context.term()

    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)

            expect_reply = True
            while expect_reply:
                socks = dict(poll.poll(REQUEST_TIMEOUT))
                if socks.get(client) == zmq.POLLIN:
                    reply = client.recv()
                    print(reply)
                    print(self.thishash(request))
                    if not reply:
                        break
                    if reply.decode() == self.thishash(request):
                        print("I: Server replied OK (%s)" % reply)
                        retries_left = 0
                        data = 'server get you request'
                        expect_reply = False
                    else:
                        print("E: Malformed reply from server: %s" % reply)

                else:
                    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)

    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()

    
def poh_tx(self, dict, node_count):
        alf = "abcdefghijklmnopqrstuvwxyz"
        hash = self.thishash(dict)
        hash = hash.lower()
        hash_modif = hash
        # hash_modif_sum = 1
        for i in range(len(hash)):
            if hash[i] in alf:
                hash_modif = hash_modif.replace(hash[i], str(ord(hash[i])-96))
        hash_sum = node_count + 10
        round = 0
        while hash_sum > node_count and hash_sum > 9:
            round += 1
            hash_modif = hash_modif.replace(str(round - 1), str(round))
            hash_modif_sum = hash_modif
            while hash_sum > node_count and hash_sum > 9:
                hash_sum = int(hash_modif_sum[:1]) + int(hash_modif_sum[1:len(hash_modif)])
                hash_modif_sum = str(hash_sum)

            break

        # если нод меньше 9, тогда
        if node_count < 9:
            hash_modif_sum = int(hash_modif_sum)
            while hash_modif_sum > node_count:
                hash_modif_sum = hash_modif_sum // 2
        return int(hash_modif_sum)

from __future__ import print_function

import time
import zmq
import sys
import threading
from random import randint, random


class ClientTask(threading.Thread):
    """ClientTask"""
    def __init__(self, id):
        self.id = id
        threading.Thread.__init__ (self)

    def run(self):
        context = zmq.Context()
        socket = context.socket(zmq.DEALER)
        identity = u'client-%d' % self.id
        socket.identity = identity.encode('ascii')
        socket.connect('tcp://localhost:5556')
        print('Клиент %s запустился' % (identity))
        poll = zmq.Poller()
        poll.register(socket, zmq.POLLIN)
        reqs = 0
        while True:

            reqs = reqs + 1
            print('Запрос #%d отправлен..' % (reqs))
            send_msg = {'task': 'iamalive', 'msg': reqs}
            send_msg = str(send_msg).encode()
            socket.send(send_msg)
            #socket.send_string(u'запрос #%d' % (reqs))
            sockets = dict(poll.poll())

            if socket in sockets:
                msg = socket.recv()
                print('Клиент %s ответил: %s' % (identity, msg))
                break
        socket.close()
        context.term()    

def main():
    x = 0
    while True:
        x += 1
        client = ClientTask(x)
        client.start()

if __name__ == 

from __future__ import print_function

from random import randint
import time
import zmq
import threading

from cl_node import *


node = Node()

#
# это порт чисто для обработки взаимодействия последних нод
# получаем сообщения от других нод и обрабатываем их
#
def get_router():
    print('Wait connection ROUTER (Thread 2)...')
    # Prepare our context and sockets
    ctx = zmq.Context()
    frontend = ctx.socket(zmq.ROUTER)
    frontend.bind("tcp://*:5556")

    # Initialize poll set
    poller = zmq.Poller()
    poller.register(frontend, zmq.POLLIN)

    while True:
        try:
            items = dict(poller.poll())
        except:
            break  # Interrupted

        if frontend in items:
            msg = frontend.recv_multipart()
            #
            # Проверка на живучесть
            #
            if b'iamalive' in msg[1]:
                msg_dict = eval(msg[1])
                print('from DEALER - ', msg[0],': ',msg[1])
                msg[1] = b'Ok'
                frontend.send_multipart(msg)

def main():
    #
    # включаем поток для прослушки порта 5556 в режиме ROUTER
    #
    my_thread_router = threading.Thread(target=get_router, args=())
    my_thread_router.start()
    node.alive_start_server()


if __name__ == "__main__":
    main()

class ServerTask(threading.Thread):
    def __init__(self):
        threading.Thread.__init__ (self)

    def run(self):
        context = zmq.Context()
        frontend = context.socket(zmq.ROUTER)
        frontend.bind('tcp://*:5556')

        backend = context.socket(zmq.DEALER)
        backend.bind('inproc://backend')

        workers = []
        for i in range(5):
            worker = ServerWorker(context)
            worker.start()
            workers.append(worker)

        zmq.proxy(frontend, backend)

        frontend.close()
        backend.close()
        context.term()


class ServerWorker(threading.Thread):
    def __init__(self, context):
        threading.Thread.__init__ (self)
        self.context = context

    def run(self):
        worker = self.context.socket(zmq.DEALER)
        worker.connect('inproc://backend')
        identity_w = "%04X-%04X" % (randint(0, 0x10000), randint(0, 0x10000)) # это внутренний id, не zmq
        print('Worker '+identity_w+' started')
        while True:
            ident, msg = worker.recv_multipart()
            print('Worker received %s from %s' % (msg, ident))
            self.test_task(worker,ident,msg)
            #replies = randint(0,3)
            #for i in range(replies):
                #time.sleep((randint(0,2)))
                #msg = eval(msg)
                #msg['worker'] = identity_w
                #msg = str(msg).encode()
                #worker.send_multipart([ident, msg])
        worker.close()

    def test_task(self,worker,ident,msg):
        msg = eval(msg)
        # запрос last vector для поиска nonce
        if 'nonce' in msg['task']:
            print('Запрос vector')
            msg['task'] = 'vector-file'
            msg['msg'] = node.vector_only_my_node_GET()
            msg = str(msg).encode()
            worker.send_multipart([ident, msg])
            return

        if 'vector-pow' in msg['task']:
            print('Запрос vector pow')
            msg = node.vector_check_POW(msg['msg'])
            msg = str(msg).encode()
            worker.send_multipart([ident, msg])
            worker.send_multipart([ident, PPP_END])
            return