Пример #1
0
def peer_check(peer, DB):
    peers=tools.db_get('peers')
    if peers[peer]['length']==0 or random.random()<0.1:
        ask_for_count(peer)
        out=trade_peers(peer)
        if type(out)==dict and 'error' in out:
            return 1
    peers=tools.db_get('peers')
    length = tools.db_get('length')
    diffLength= tools.db_get('diffLength')
    size = max(len(diffLength), len(peers[peer]['diffLength']))
    us = tools.buffer_(diffLength, size)
    them = tools.buffer_(peers[peer]['diffLength'], size)
    if them < us:
        return give_block(peer, DB, peers[peer]['length'])
    elif us == them:
        try:
            ask_for_count(peer)
            trade_peers(peer)
            return ask_for_txs(peer, DB)
        except Exception as exc:
            tools.log('ask for tx error')
            tools.log(exc)
    else:
        return download_blocks(peer, DB, peers[peer]['length'], length)
Пример #2
0
def peer_check(i, peers, DB):
    peer=peers[i][0]
    block_count = cmd(peer, {'type': 'blockCount'})
    if not isinstance(block_count, dict):
        return
    if 'error' in block_count.keys():
        return
    peers[i][2]=block_count['diffLength']
    peers[i][3]=block_count['length']
    length = tools.db_get('length')
    diffLength= tools.db_get('diffLength')
    size = max(len(diffLength), len(block_count['diffLength']))
    us = tools.buffer_(diffLength, size)
    them = tools.buffer_(block_count['diffLength'], size)
    if them < us:
        give_block(peer, DB, block_count['length'])
    elif us == them:
        try:
            ask_for_txs(peer, DB)
        except Exception as exc:
            tools.log('ask for tx error')
            tools.log(exc)
    else:
        download_blocks(peer, DB, block_count, length)
    F=False
    my_peers=tools.db_get('peers_ranked')
    their_peers=cmd(peer, {'type':'peers'})
    if type(my_peers)==list:
        for p in their_peers:
            if p not in my_peers:
                F=True
                my_peers.append(p)
    if F:
        tools.db_put('peers_ranked', my_peers)
Пример #3
0
    def peer_check(peer, DB):

        def cmd(x):
            return networking.send_command(peer, x)

        def download_blocks(peer, DB, peers_block_count, length):

            def fork_check(newblocks, DB):
                block = blockchain.db_get(DB['length'], DB)
                recent_hash = tools.det_hash(block)
                their_hashes = map(tools.det_hash, newblocks)
                return recent_hash not in their_hashes

            def bounds(length, peers_block_count):
                if peers_block_count['length'] - length > custom.download_many:
                    end = length + custom.download_many - 1
                else:
                    end = peers_block_count['length']
                return [max(length - 2, 0), end]

            blocks = cmd({'type': 'rangeRequest',
                          'range': bounds(length, peers_block_count)})
            if not isinstance(blocks, list):
                return []
            for i in range(2):  # Only delete a max of 2 blocks, otherwise a
                # peer might trick us into deleting everything over and over.
                if fork_check(blocks, DB):
                    blockchain.delete_block(DB)
            DB['suggested_blocks'].extend(blocks)
            return

        def ask_for_txs(peer, DB):
            txs = cmd({'type': 'txs'})
            DB['suggested_txs'].extend(txs)
            pushers = [x for x in DB['txs'] if x not in txs]
            for push in pushers:
                cmd({'type': 'pushtx', 'tx': push})
            return []

        def give_block(peer, DB, block_count):
            cmd({'type': 'pushblock',
                 'block': blockchain.db_get(block_count['length'] + 1,
                                            DB)})
            return []

        block_count = cmd({'type': 'blockCount'})
        if not isinstance(block_count, dict):
            return
        if 'error' in block_count.keys():
            return
        length = DB['length']
        size = max(len(DB['diffLength']), len(block_count['diffLength']))
        us = tools.buffer_(DB['diffLength'], size)
        them = tools.buffer_(block_count['diffLength'], size)
        if them < us:
            return give_block(peer, DB, block_count)
        if us == them:
            return ask_for_txs(peer, DB)
        return download_blocks(peer, DB, block_count, length)
Пример #4
0
def peer_check(peer, DB):
    block_count = cmd(peer, {'type': 'blockCount'})
    if not isinstance(block_count, dict):
        return
    if 'error' in block_count.keys():
        return
    length = DB['length']
    size = max(len(DB['diffLength']), len(block_count['diffLength']))
    us = tools.buffer_(DB['diffLength'], size)
    them = tools.buffer_(block_count['diffLength'], size)
    if them < us:
        return give_block(peer, DB, block_count['length'])
    if us == them:
        return ask_for_txs(peer, DB)
    return download_blocks(peer, DB, block_count, length)
Пример #5
0
def send_msg(data, sock):
    data=tools.package(data)
    data=tools.buffer_(str(len(data)), 5)+data
    while data:
        time.sleep(0.0001)
        try:
            sent = sock.send(data)
        except:
            return 'peer died'
        data = data[sent:]
    return 0
Пример #6
0
def hexInvert(n):
    # Use double-size for division, to reduce information leakage.
    return tools.buffer_(str(hex(int('f' * 128, 16) / int(n, 16)))[2: -1], 64)
Пример #7
0
def hexSum(a, b):
    # Sum of numbers expressed as hexidecimal strings
    return tools.buffer_(str(hex(int(a, 16)+int(b, 16)))[2: -1], 64)
Пример #8
0
 def targetTimesFloat(target, number):
     a = int(str(target), 16)
     b = int(a * number)
     return tools.buffer_(str(hex(b))[2:-1], 64)
Пример #9
0
 def targetTimesFloat(target, number):
     a = int(str(target), 16)
     b = int(a * number)
     return tools.buffer_(str(hex(b))[2: -1], 64)
Пример #10
0
def hexSum(a, b):
    # Sum of numbers expressed as hexidecimal strings
    return tools.buffer_(str(hex(int(a, 16) + int(b, 16)))[2:-1], 64)
Пример #11
0
def hexInvert(n):
    # Use double-size for division, to reduce information leakage.
    return tools.buffer_(str(hex(int('f' * 128, 16) / int(n, 16)))[2:-1], 64)
Пример #12
0
 def targetTimesFloat(target, number):
     a = int(str(target), 16)
     b = int(
         a * number
     )  # this should be rational multiplication followed by integer estimation
     return tools.buffer_(str(hex(b))[2:-1], 64)
Пример #13
0
 def targetTimesFloat(target, number):
     a = int(str(target), 16)
     b = int(a * number)#this should be rational multiplication followed by integer estimation
     return tools.buffer_(str(hex(b))[2: -1], 64)
Пример #14
0
    def peer_check(peer, DB):
        def cmd(x):
            return networking.send_command(peer, x)

        def download_blocks(peer, DB, peers_block_count, length):
            def fork_check(newblocks, DB):
                length = copy.deepcopy(DB['length'])
                block = blockchain.db_get(length, DB)
                recent_hash = tools.det_hash(block)
                their_hashes = map(tools.det_hash, newblocks)
                return recent_hash not in map(tools.det_hash, newblocks)

            def bounds(length, peers_block_count, DB):
                if peers_block_count['length'] - length > custom.download_many:
                    end = length + custom.download_many - 1
                else:
                    end = peers_block_count['length']
                return [max(length - 2, 0), end]

            blocks = cmd({
                'type': 'rangeRequest',
                'range': bounds(length, peers_block_count, DB)
            })
            if type(blocks) != type([1, 2]):
                return []
            for i in range(10):  # Only delete a max of 20 blocks, otherwise a
                # peer might trick us into deleting everything over and over.
                if fork_check(blocks, DB):
                    blockchain.delete_block(DB)
            DB['suggested_blocks'] += blocks
            return

        def ask_for_txs(peer, DB):
            txs = cmd({'type': 'txs'})
            for tx in txs:
                DB['suggested_txs'].append(tx)
            pushers = [x for x in DB['txs'] if x not in txs]
            for push in pushers:
                cmd({'type': 'pushtx', 'tx': push})
            return []

        def give_block(peer, DB, block_count):
            cmd({
                'type': 'pushblock',
                'block': blockchain.db_get(block_count['length'] + 1, DB)
            })
            return []

        block_count = cmd({'type': 'blockCount'})
        if type(block_count) != type({'a': 1}):
            return
        if 'error' in block_count.keys():
            return
        length = DB['length']
        size = max(len(DB['diffLength']), len(block_count['diffLength']))
        us = tools.buffer_(DB['diffLength'], size)
        them = tools.buffer_(block_count['diffLength'], size)
        if them < us:
            return give_block(peer, DB, block_count)
        if us == them:
            return ask_for_txs(peer, DB)
        return download_blocks(peer, DB, block_count, length)