Topic: Ⓐ Atom - I write crypto currency ✌✌✌ (Read 126 times)

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: Пepecылaю (%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)

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

import socket
import time
import threading

#
# Ждeм cooбщeния oт нoды 1264
#
def server():
    # cлyшaeм и oтпpaвляeм дaнныe
    s = socket.socket(socket.AF_INET,      # зaдaмeм ceмeйcтвo пpoтoкoлoв 'Интepнeт' (INET)
                          socket.SOCK_STREAM,  # зaдaeм тип пepeдaчи дaнныx 'пoтoкoвый' (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:
            # Пoкa клиeнт нe oтключилcя, читaeм пepeдaвaeмыe
            # им дaнныe и oтпpaвляeм иx oбpaтнo
            data = c.recv(1024)
            if not data:
                # Клиeнт oтключилcя
                break
            else:
                print(data.decode())

#
# Oтпpaвляeм cooбщeния нoдe нa 1265 пopтy
#
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()

     
    
        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)

       
        generate_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
        public_key = generate_key.get_verifying_key() # clear key:
        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))