Exemplo n.º 1
0
def home(DB, dic):
    if 'BrainWallet' in dic:
        dic['privkey'] = tools.det_hash(dic['BrainWallet'])
    elif 'privkey' not in dic:
        return "<p>You didn't type in your brain wallet.</p>"
    privkey = dic['privkey']
    pubkey = tools.privtopub(dic['privkey'])
    address = tools.make_address([pubkey], 1)
    if 'do' in dic:
        if dic['do'] == 'spend':
            spend(float(dic['amount']), pubkey, privkey, dic['to'], DB)
    out = empty_page
    out = out.format('<p>your address: ' + str(address) + '</p>{}')
    out = out.format('<p>current block: ' + str(DB['length']) + '</p>{}')
    balance = blockchain.db_get(address, DB)['amount']
    for tx in DB['txs']:
        if tx['type'] == 'spend' and tx['to'] == address:
            balance += tx['amount'] - custom.fee
        if tx['type'] == 'spend' and tx['pubkeys'][0] == pubkey:
            balance -= tx['amount']
    out = out.format('<p>current balance is: ' + str(balance/100000.0) + '</p>{}')
    if balance > 0:
        out = out.format(easyForm('/home', 'spend money', '''
        <input type="hidden" name="do" value="spend">
        <input type="text" name="to" value="address to give to">
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(privkey)))
    txt='''    <input type="hidden" name="privkey" value="{}">'''
    s = easyForm('/home', 'Refresh', txt.format(privkey))
    return out.format(s)
Exemplo n.º 2
0
def home(DB, dic):
    if 'BrainWallet' in dic:
        dic['privkey']=tools.det_hash(dic['BrainWallet'])
    elif 'privkey' not in dic:
        return "<p>You didn't type in your brain wallet.</p>"
    privkey=dic['privkey']
    pubkey=tools.privtopub(dic['privkey'])
    address=tools.make_address([pubkey], 1)
    if 'do' in dic.keys():
        if dic['do']=='spend':
            spend(float(dic['amount']), pubkey, privkey, dic['to'], DB)
    out=empty_page
    out=out.format('<p>your address: ' +str(address)+'</p>{}')
    out=out.format('<p>current block: ' +str(DB['length'])+'</p>{}')
    balance=blockchain.db_get(address, DB)['amount']
    for tx in DB['txs']:
        if tx['type'] == 'spend' and tx['to'] == address:
            balance += tx['amount'] - custom.fee
        if tx['type'] == 'spend' and tx['pubkeys'][0] == pubkey:
            balance -= tx['amount']
    out=out.format('<p>current balance is: ' +str(balance/100000.0)+'</p>{}')
    if balance>0:
        out=out.format(easyForm('/home', 'spend money', '''
        <input type="hidden" name="do" value="spend">
        <input type="text" name="to" value="address to give to">
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(privkey)))    
    txt='''    <input type="hidden" name="privkey" value="{}">'''
    s=easyForm('/home', 'Refresh', txt.format(privkey))
    return out.format(s)
Exemplo n.º 3
0
def main(c=0):
    if type(c)==int:
        p={'command':sys.argv[1:]}
    else:
        p={'command':c}
    if len(p['command'])==0:
        p['command'].append(' ')
    c=p['command']
    if c[0]=='make_PM':
        tx=build_pm()
        return run_command({'command':['pushtx', tools.package(tx).encode('base64')]})
    elif c[0]=='buy_shares':
        tx=build_buy_shares()
        return run_command({'command':['pushtx', tools.package(tx).encode('base64')]})
    elif c[0]=='start':
        r=connect({'command':'blockcount'})
        if is_off(r):
            p=raw_input('what is your password?\n')
            daemonize(lambda: threads.main(p))
        else:
            print('blockchain is already running')
    elif c[0]=='new_address':
        if len(c)<2:
            print('what is your brain wallet? not enough inputs.')
        else:
            privkey=tools.det_hash(c[1])
            pubkey=tools.privtopub(privkey)
            address=tools.make_address([pubkey], 1)
            return({'brain':str(c[1]),
                    'privkey':str(privkey),
                    'pubkey':str(pubkey),
                    'address':str(address)})
    else:
        return run_command(p)
Exemplo n.º 4
0
def easy_add_transaction(tx_orig, privkey='default'):
    tx = copy.deepcopy(tx_orig)
    if privkey in ['default', 'Default']:
        if tools.db_existence('privkey'):
            privkey = tools.db_get('privkey')
        else:
            return 'No private key is known, so the tx cannot be signed. '

    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)

    if 'count' not in tx:
        try:
            tx['count'] = tools.count(address, {})
        except:
            tx['count'] = 1

    # add our pubkey
    if 'pubkeys' not in tx:
        tx['pubkeys'] = [pubkey]

    # this is IMPORTANT
    # when adding new transaction which is signed by us,
    # this procedure is applied. tx without signatures is signed with our privkey.
    if 'signatures' not in tx:
        tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    return blockchain.add_tx(tx)
Exemplo n.º 5
0
def sign(tx, privkey):
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    if 'pubkeys' not in tx:
        tx['pubkeys'] = [pubkey]
    if 'signatures' not in tx:
        tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    return tx
Exemplo n.º 6
0
def sign(tx, privkey):
    pubkey=tools.privtopub(privkey)
    address=tools.make_address([pubkey], 1)
    if 'pubkeys' not in tx:
        tx['pubkeys']=[pubkey]
    if 'signatures' not in tx:
        tx['signatures']=[tools.sign(tools.det_hash(tx), privkey)]
    return tx
Exemplo n.º 7
0
def easy_add_transaction(tx_orig, privkey, DB):
    tx=copy.deepcopy(tx_orig)
    pubkey=tools.privtopub(privkey)
    try:
        tx['count']=blockchain.count(pubkey, DB)
    except:
        tx['count']=1
    tx['signature']=tools.sign(tools.det_hash(tx), privkey)
    blockchain.add_tx(tx, DB)
Exemplo n.º 8
0
def sign(tx, privkey):
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    tx = add_recent_hash(tx)
    if "pubkeys" not in tx:
        tx["pubkeys"] = [pubkey]
    if "signatures" not in tx:
        tx["signatures"] = [tools.sign(tools.det_hash(tx), privkey)]
    return tx
Exemplo n.º 9
0
def easy_add_transaction(tx_orig, privkey, DB):
    tx = copy.deepcopy(tx_orig)
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    try:
        tx['count'] = blockchain.count(address, DB)
    except:
        tx['count'] = 1
    tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    blockchain.add_tx(tx, DB)
Exemplo n.º 10
0
def easy_add_transaction(tx_orig, privkey, DB):
    tx=copy.deepcopy(tx_orig)
    pubkey=tools.privtopub(privkey)
    address=tools.make_address([pubkey], 1)
    try:
        tx['count']=blockchain.count(address, DB)
    except:
        tx['count']=1
    tx['signatures']=[tools.sign(tools.det_hash(tx), privkey)]
    blockchain.add_tx(tx, DB)
Exemplo n.º 11
0
def easy_add_transaction(tx_orig, DB, privkey='default'):
    tx = copy.deepcopy(tx_orig)
    try:
        tx['count'] = tools.count(DB['address'], DB)
    except:
        tx['count'] = 1
    if privkey=='default':
        if 'privkey' in DB:
            privkey=DB['privkey']
        else:
            return('no private key is known, so the tx cannot be signed. Here is the tx: \n'+str(tools.package(tx_orig).encode('base64').replace('\n', '')))
    if 'pubkeys' not in tx:
        tx['pubkeys']=[tools.privtopub(privkey)]
    tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    tools.log('collect winnings 3')
    return(blockchain.add_tx(tx, DB))
Exemplo n.º 12
0
def trade_shares(DB, args):  #args = [ PM_id, buy ]
    privkey = tools.db_get('privkey')
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    tx = {
        'type': 'buy_shares',
        'PM_id': args[0],
        'buy': csv2vec(args[1]),
        'pubkeys': [pubkey],
        'count': tools.count(address, {})
    }
    cost = txs_tools.cost_to_buy_shares(tx)
    tx['price_limit'] = int(cost * 1.01) + 1
    tx = tools.unpackage(tools.package(tx))
    tx = tools.POW(tx)
    tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    return easy_add_transaction(tx, DB, privkey)
Exemplo n.º 13
0
def common_buy_shares(tx, num_states, brainwallet):
    privkey = tools.det_hash(brainwallet)
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    tx['pubkeys'] = [pubkey]
    tx['count'] = tools.count(address, {})
    cost = txs_tools.cost_to_buy_shares(tx)
    tx['price_limit'] = int(cost * 1.01) + 1
    print(
        'now for a little proof of work. This may take several minutes. The purpose of this pow is to make it more difficult for a front runner to steal your trade.'
    )
    tx = tools.unpackage(tools.package(tx))
    tx = tools.POW(tx)
    tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    print('tx for copy/pasting into pushtx: ' +
          tools.package(tx).encode('base64'))
    return tx
Exemplo n.º 14
0
def easy_add_transaction(tx_orig, DB, privkey='default'):
    tx = copy.deepcopy(tx_orig)
    if privkey in ['default', 'Default']:
        if tools.db_existence('privkey'):
            privkey=tools.db_get('privkey')
        else:
            return('no private key is known, so the tx cannot be signed. Here is the tx: \n'+str(tools.package(tx_orig).encode('base64').replace('\n', '')))
    pubkey=tools.privtopub(privkey)
    address=tools.make_address([pubkey], 1)
    if 'count' not in tx:
        try:
            tx['count'] = tools.count(address, {})
        except:
            tx['count'] = 1
    if 'pubkeys' not in tx:
        tx['pubkeys']=[pubkey]
    if 'signatures' not in tx:
        tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    return(blockchain.add_tx(tx, DB))
Exemplo n.º 15
0
def easy_add_transaction(tx_orig, DB, privkey='default'):
    tx = copy.deepcopy(tx_orig)
    if privkey in ['default', 'Default']:
        if tools.db_existence('privkey'):
            privkey = tools.db_get('privkey')
        else:
            return ('no private key is known, so the tx cannot be signed. Here is the tx: \n' + str(
                tools.package(tx_orig).encode('base64').replace('\n', '')))
    pubkey = tools.privtopub(privkey)
    address = tools.make_address([pubkey], 1)
    if 'count' not in tx:
        try:
            tx['count'] = tools.count(address, {})
        except:
            tx['count'] = 1
    if 'pubkeys' not in tx:
        tx['pubkeys'] = [pubkey]
    if 'signatures' not in tx:
        tx['signatures'] = [tools.sign(tools.det_hash(tx), privkey)]
    return (blockchain.add_tx(tx, DB))
Exemplo n.º 16
0
def build_buy_shares():
    tx={'type':'buy_shares', 'PM_id':str(raw_input('What is the unique name for this prediction market?\n>'))}
    num_states=int(raw_input('how many states does this pm have?\n>'))
    tx['buy']=[]
    for i in range(num_states):
        tx['buy'].append(int(raw_input('how many shares do you want to buy of state '+str(i)+'? To sell states, use negative numbers.\n>')))
    brainwallet=str(raw_input('What is your brainwallet\n>'))
    privkey=tools.det_hash(brainwallet)
    pubkey=tools.privtopub(privkey)
    address=tools.make_address([pubkey], 1)
    tx['pubkeys']=[pubkey]
    tx['count'] = tools.count(address, {})
    cost=txs_tools.cost_to_buy_shares(tx)
    tx['price_limit']=int(cost*1.01)
    print('now for a little proof of work. This may take several minutes. The purpose of this pow is to make it more difficult for a front runner to steal your trade.')
    tx=tools.unpackage(tools.package(tx))
    tx=tools.POW(tx)
    tx['signatures']=[tools.sign(tools.det_hash(tx), privkey)]
    print('tx for copy/pasting into pushtx: '+tools.package(tx).encode('base64'))
    return tx
Exemplo n.º 17
0
def main():
    info=sys.argv
    p={'command':sys.argv[1:]}
    if len(p['command'])==0:
        p['command'].append(' ')
    c=p['command']
    if c[0]=='make_PM':
        tx=build_pm()
        run_command({'command':['pushtx', tools.package(tx).encode('base64')]})
    elif c[0]=='buy_shares':
        tx=build_buy_shares()
        run_command({'command':['pushtx', tools.package(tx).encode('base64')]})
    elif c[0]=='start':
        r=connect({'command':'blockcount'})
        if is_truthcoin_off(r):
            p=raw_input('what is your password?\n')
            if sys.platform == 'win32':
                pypath = list(os.path.split(sys.executable))
                pypath[-1] = 'pythonw.exe'
                os.system('start '+os.path.join(*pypath)+' threads.py '+p)
                sys.exit(0)
            else:
                daemonize(lambda: threads.main(p))
        else:
            print('truthcoin is already running')
    elif c[0]=='new_address':
        if len(c)<2:
            print('what is your brain wallet? not enough inputs.')
        else:
            privkey=tools.det_hash(c[1])
            pubkey=tools.privtopub(privkey)
            address=tools.make_address([pubkey], 1)
            print('brain: ' +str(c[1]))
            print('privkey: ' +str(privkey))
            print('pubkey: ' +str(pubkey))
            print('address: ' +str(address))
    else:
        run_command(p)
Exemplo n.º 18
0
def main(brainwallet, pubkey_flag=False):
    DB=custom.DB
    tools.log('custom.current_loc: ' +str(custom.current_loc))
    print('starting truthcoin')
    if not pubkey_flag:
        privkey=tools.det_hash(brainwallet)
        pubkey=tools.privtopub(privkey)
    else:
        pubkey=brainwallet
    a=tools.empty_peer()
    a['port']=custom.port
    b=custom.peers
    my_ip=tools.getPublicIp()
    b[my_ip+':'+str(custom.port)]=a
    processes= [
        {'target': blockchain.main,
         'args': (DB,),
         'name': 'blockchain'},
        {'target': truthcoin_api.main,
         'args': (DB, DB['heart_queue']),
         'name': 'truthcoin_api'},
        {'target': peers_check.main,
         'args': (b, DB),
         'name': 'peers_check'},
        {'target': miner.main,
         'args': (pubkey, DB),
         'name': 'miner'},
        {'target': networking.serve_forever,
         'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
         'name': 'peer_recieve'}
    ]
    cmds=[database.DatabaseProcess(
        DB['heart_queue'],
        custom.database_name,
        tools.log,
        custom.database_port)]
    try:
        cmds[0].start()
    except Exception as exc:
        tools.log(exc)
    tools.log('starting ' + cmds[0].name)
    time.sleep(4)
    tools.db_put('test', 'TEST')
    tools.db_get('test')
    tools.db_put('test', 'undefined')
    b=tools.db_existence(0)
    if not b:
        tools.db_put('ip', my_ip)
        tools.db_put('length', -1)
        tools.db_put('memoized_votes', {})
        tools.db_put('txs', [])
        tools.db_put('peers', {})
        tools.db_put('targets', {})
        tools.db_put('times', {})
        tools.db_put('mine', False)
        tools.db_put('diffLength', '0')
    tools.db_put('stop', False)
    tools.log('stop: ' +str(tools.db_get('stop')))
    for process in processes:
        cmd=multiprocessing.Process(**process)
        cmd.start()
        cmds.append(cmd)
        tools.log('starting '+cmd.name)
    if not pubkey_flag:
        tools.db_put('privkey', privkey)
    else:
        tools.db_put('privkey', 'Default')
    tools.db_put('address', tools.make_address([pubkey], 1))
    tools.log('stop: ' +str(tools.db_get('stop')))
    while not tools.db_get('stop'):
        time.sleep(0.5)
    tools.log('about to stop threads')
    DB['heart_queue'].put('stop')
    for p in [[custom.port, '127.0.0.1'],
              [custom.api_port, '127.0.0.1']]:
        networking.connect('stop', p[0], p[1])
    cmds.reverse()
    for cmd in cmds[:-1]:
        cmd.join()
        tools.log('stopped a thread: '+str(cmd))
    time.sleep(2)
    networking.connect('stop', custom.database_port, '127.0.0.1')
    cmds[-1].join()
    tools.log('stopped a thread: '+str(cmds[-1]))
    tools.log('all threads stopped')
    sys.exit(0)
Exemplo n.º 19
0
gui_port = 8700
version = "VERSION"
block_reward = 10**5
premine = 5 * 10**6
fee = 10**3
# Lower limits on what the "time" tag in a block can say.
mmm = 100
# Take the median of this many of the blocks.
# How far back in history do we look when we use statistics to guess at
# the current blocktime and difficulty.
history_length = 400
# This constant is selected such that the 50 most recent blocks count for 1/2 the
# total weight.
inflection = 0.985
download_many = 500  # Max number of blocks to request from a peer at the same time.
max_download = 50000
brainwallet = 'brain wallet'
privkey = tools.det_hash(brainwallet)
pubkey = tools.privtopub(privkey)
master_pubkey = tools.privtopub(privkey)
peers = [['localhost', 8901], ['localhost', 8902], ['localhost', 8903],
         ['localhost', 8904], ['localhost', 8905]]
hashes_per_check = 10**5


def blocktime(length):
    if length * block_reward < premine:
        return 30  # seconds
    else:
        return 60
Exemplo n.º 20
0
def main(wallet_name='', key=''):
    tools.log('custom.current_loc: ' + str(custom.current_loc))

    print('Starting Coinami Client ...')

    b = tools.db_existence('length')
    # Initialize the db
    if not b:
        tools.db_put('length', -1)
        tools.db_put('memoized_votes', {})
        tools.db_put('txs', [])
        tools.db_put('peers_ranked', [])
        tools.db_put('times', {})
        tools.db_put('mine', False)
        tools.db_put('peers', [])
        tools.db_put('authorities', [])
        tools.db_put('miner_status', 'Uninitialized')
        tools.db_put('miner_id', -1)
        tools.db_put('default_wallet', False)

    tools.db_put('stop', False)
    tools.log('stop: ' + str(tools.db_get('stop')))

    wallet = {}
    if key == '':
        wallet['valid'] = False
        wallet['message'] = 'Please define a passphrase to open the wallet'
    if wallet_name == '':
        wallet_name = tools.db_get('default_wallet')
        if not tools.db_get('default_wallet'):
            wallet['valid'] = False
            wallet['message'] = 'There is no defined default wallet. You need to specify one.'
        else:
            wallet = tools.read_wallet(wallet_name, key)

    elif wallet_name != '':
        wallet = tools.read_wallet(wallet_name, key)

    if not wallet['valid']:
        print wallet['message']
        sys.exit(0)

    # Take the initial peer and authority list over here. Also a download link for executable. 
    # Download can be started when miner is opened for the first time.
    # Peers and authorities must be set immediately.

    seed = str(wallet['seed'])
    try:
        info = json.loads(urllib2.urlopen(custom.info_address).read())
    except:
        print 'Could not read info file'
        sys.exit(0)

    peers = []
    for authority in info['authorities']:
        peers.append([authority['ip'], authority['port']])

    authorities = []
    for authority in info['authorities']:
        authorities.append(authority['pubkey'])

    tools.db_put('seed', seed)
    tools.db_put('info', info)
    tools.db_put('peers', peers)
    tools.db_put('authorities', authorities)
    tools.db_put('default_wallet', wallet_name)

    privkey = tools.det_hash(wallet['seed'])
    pubkey = tools.privtopub(privkey)

    tools.db_put('privkey', privkey)
    tools.db_put('pubkey', pubkey)

    processes = [
        {'target': tools.heart_monitor,
         'name': 'heart_monitor'},
        {'target': blockchain.main,
         'name': 'blockchain'},
        {'target': api.main,
         'name': 'api'},
        {'target': peers_check.main,
         'args': (tools.db_get('peers'),),
         'name': 'peers_check'},
        {'target': networking.serve_forever,
         'args': (peer_recieve_func, custom.port, custom.queues['heart_queue'], True),
         'name': 'peer_recieve'},
        {'target': miner.main,
         'args': (pubkey, ),
         'name': 'miner'}
    ]

    running_processes = []
    for process in processes[1:]:
        cmd = multiprocessing.Process(**process)
        cmd.start()
        running_processes.append(cmd)
        tools.log('starting ' + cmd.name)

    tools.db_put('address', tools.make_address([pubkey], 1))
    tools.log('stop: ' + str(tools.db_get('stop')))

    # until stop command puts into db, threads module will stay in this loop
    while not tools.db_get('stop'):
        time.sleep(0.5)

    # start the stopping
    custom.queues['heart_queue'].put('stop')
    for p in [[custom.port, '127.0.0.1'],
              [custom.api_port, '127.0.0.1']]:
        networking.connect('stop', p[0], p[1])
    running_processes.reverse()

    # process = psutil.Process(os.getpid())
    # for proc in process.get_children(recursive=True):
    #    print proc.pid
    #    proc.kill()

    time.sleep(2)

    for cmd in running_processes[:-1]:
        print 'im waiting for %s' % str(cmd)
        cmd.terminate()
        cmd.join()

    print('all processes stopped')
    sys.exit(0)
Exemplo n.º 21
0
def main(wallet_name='', key=''):
    tools.log('custom.current_loc: ' + str(custom.current_loc))

    print('Starting Coinami Client ...')

    b = tools.db_existence('length')
    # Initialize the db
    if not b:
        tools.db_put('length', -1)
        tools.db_put('memoized_votes', {})
        tools.db_put('txs', [])
        tools.db_put('peers_ranked', [])
        tools.db_put('times', {})
        tools.db_put('mine', False)
        tools.db_put('peers', [])
        tools.db_put('authorities', [])
        tools.db_put('miner_status', 'Uninitialized')
        tools.db_put('miner_id', -1)
        tools.db_put('default_wallet', False)

    tools.db_put('stop', False)
    tools.log('stop: ' + str(tools.db_get('stop')))

    wallet = {}
    if key == '':
        wallet['valid'] = False
        wallet['message'] = 'Please define a passphrase to open the wallet'
    if wallet_name == '':
        wallet_name = tools.db_get('default_wallet')
        if not tools.db_get('default_wallet'):
            wallet['valid'] = False
            wallet[
                'message'] = 'There is no defined default wallet. You need to specify one.'
        else:
            wallet = tools.read_wallet(wallet_name, key)

    elif wallet_name != '':
        wallet = tools.read_wallet(wallet_name, key)

    if not wallet['valid']:
        print wallet['message']
        sys.exit(0)

    # Take the initial peer and authority list over here. Also a download link for executable.
    # Download can be started when miner is opened for the first time.
    # Peers and authorities must be set immediately.

    seed = str(wallet['seed'])
    try:
        info = json.loads(urllib2.urlopen(custom.info_address).read())
    except:
        print 'Could not read info file'
        sys.exit(0)

    peers = []
    for authority in info['authorities']:
        peers.append([authority['ip'], authority['port']])

    authorities = []
    for authority in info['authorities']:
        authorities.append(authority['pubkey'])

    tools.db_put('seed', seed)
    tools.db_put('info', info)
    tools.db_put('peers', peers)
    tools.db_put('authorities', authorities)
    tools.db_put('default_wallet', wallet_name)

    privkey = tools.det_hash(wallet['seed'])
    pubkey = tools.privtopub(privkey)

    tools.db_put('privkey', privkey)
    tools.db_put('pubkey', pubkey)

    processes = [{
        'target': tools.heart_monitor,
        'name': 'heart_monitor'
    }, {
        'target': blockchain.main,
        'name': 'blockchain'
    }, {
        'target': api.main,
        'name': 'api'
    }, {
        'target': peers_check.main,
        'args': (tools.db_get('peers'), ),
        'name': 'peers_check'
    }, {
        'target':
        networking.serve_forever,
        'args':
        (peer_recieve_func, custom.port, custom.queues['heart_queue'], True),
        'name':
        'peer_recieve'
    }, {
        'target': miner.main,
        'args': (pubkey, ),
        'name': 'miner'
    }]

    running_processes = []
    for process in processes[1:]:
        cmd = multiprocessing.Process(**process)
        cmd.start()
        running_processes.append(cmd)
        tools.log('starting ' + cmd.name)

    tools.db_put('address', tools.make_address([pubkey], 1))
    tools.log('stop: ' + str(tools.db_get('stop')))

    # until stop command puts into db, threads module will stay in this loop
    while not tools.db_get('stop'):
        time.sleep(0.5)

    # start the stopping
    custom.queues['heart_queue'].put('stop')
    for p in [[custom.port, '127.0.0.1'], [custom.api_port, '127.0.0.1']]:
        networking.connect('stop', p[0], p[1])
    running_processes.reverse()

    # process = psutil.Process(os.getpid())
    # for proc in process.get_children(recursive=True):
    #    print proc.pid
    #    proc.kill()

    time.sleep(2)

    for cmd in running_processes[:-1]:
        print 'im waiting for %s' % str(cmd)
        cmd.terminate()
        cmd.join()

    print('all processes stopped')
    sys.exit(0)
Exemplo n.º 22
0
def main(brainwallet, pubkey_flag=False):
    DB = custom.DB
    tools.log('custom.current_loc: ' + str(custom.current_loc))
    print('starting full node')
    if not pubkey_flag:
        privkey = tools.det_hash(brainwallet)
        pubkey = tools.privtopub(privkey)
    else:
        pubkey = brainwallet
    a = tools.empty_peer()
    b = custom.peers
    #b[tools.getPublicIp()+':'+str(custom.port)]=a
    processes = [
        {
            'target':
            db.main,
            'args': (DB['heart_queue'], custom.database_name, tools.log,
                     custom.database_port),
            'name':
            'db'
        },
        {
            'target': auto_signer.mainloop,
            'args': (),
            'name': 'auto_signer'
        },
        {
            'target': reward_collector.doit,
            'args': (),
            'name': 'auto_signer'
        },
        #{'target':tools.heart_monitor,
        # 'args':(DB['heart_queue'], ),
        # 'name':'heart_monitor'},
        {
            'target': blockchain.main,
            'args': (DB, ),
            'name': 'blockchain'
        },
        {
            'target': api.main,
            'args': (DB, DB['heart_queue']),
            'name': 'api'
        },
        {
            'target': peers_check.main,
            'args': (b, DB),
            'name': 'peers_check'
        },
        {
            'target': networking.serve_forever,
            'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
            'name': 'peer_recieve'
        }
    ]
    cmds = []
    cmd = multiprocessing.Process(**processes[0])
    cmd.start()
    cmds.append(cmd)
    tools.log('starting ' + cmd.name)
    time.sleep(4)
    b = tools.db_existence(0)
    #def empty_memoized(): return({'blockcount':-3000})
    if not b:
        tools.local_put('length', -1)
        tools.local_put('height', -1)
        tools.local_put('memoized_votes', {})
        tools.local_put('txs', [])
        tools.local_put('peers', {})
        tools.local_put('targets', {})
        tools.local_put('times', {})
        tools.local_put('mine', False)
        tools.local_put('my_sign_txs', {})  #empty_memoized())
        tools.local_put('secrets', {})
        money = db.default_entry()
        money['amount'] += custom.all_money
        tools.db_put(custom.creator, money)
    tools.local_put('stop', False)
    tools.log('stop: ' + str(tools.local_get('stop')))
    for process in processes[1:]:
        cmd = multiprocessing.Process(**process)
        cmd.start()
        cmds.append(cmd)
        tools.log('starting ' + cmd.name)
    if not pubkey_flag:
        tools.local_put('privkey', privkey)
    else:
        tools.local_put('privkey', 'Default')
    Address = tools.make_address([pubkey], 1)
    tools.local_put('address', Address)
    a = tools.db_proof(Address)
    tools.local_put('balance_proofs-1', a)
    tools.log('stop: ' + str(tools.local_get('stop')))
    while not tools.local_get('stop'):
        time.sleep(0.5)
    tools.log('about to stop threads')
    DB['heart_queue'].put('stop')
    for p in [[custom.port, '127.0.0.1'], [custom.api_port, '127.0.0.1']]:
        networking.connect('stop', p[0], p[1])
    cmds.reverse()
    for cmd in cmds[:-1]:
        cmd.join()
        tools.log('stopped a thread: ' + str(cmd))
    time.sleep(2)
    networking.connect('stop', custom.database_port, '127.0.0.1')
    cmds[-1].join()
    tools.log('stopped a thread: ' + str(cmds[-1]))
    tools.log('all threads stopped')
    sys.exit(0)
Exemplo n.º 23
0
def home(DB, dic):
    def display_msg(msg):
        try:
            return str(msg['msg']) + ' : ' + str(msg['reputation'] / 100000.0)
        except:
            return str(msg['msg']) + ' : ' + str(msg['amount'] / 100000.0)

    def display_posts(posts, parent, tabs):
        out = '{}'
        if tabs > 2: return out
        for pos in posts:
            id_ = transactions.postid(pos)
            if pos['parent'] == parent:
                bumper = '<div class="contentcontainer med left" style="margin-left: ' + str(
                    100 * tabs) + 'px;"><p>{}</p></div>'
                if pos in zeroth_confirmations:
                    print('pos: ' + str(pos))
                    out = out.format(bumper.format(display_msg(pos)) + '{}')
                else:
                    txt = bumper.format(
                        easyForm(
                            '/home', display_msg(pos), '''
                    <input type="hidden" name="location" value="{}">
                    <input type="hidden" name="parent" value="{}">
                    <input type="hidden" name="privkey" value="{}">'''.format(
                                id_, id_, privkey))).format('') + '{}'
                    out = out.format(txt)
                out = out.format(display_posts(posts, id_, tabs + 1))
        return out

    def balance_(address, DB):
        balance = blockchain.db_get(address, DB)['amount']
        for tx in DB['txs']:
            if tx['type'] == 'spend':
                if tx['to'] == address:
                    balance += tx['amount']
                if tx['pubkeys'][0] == pubkey:
                    balance -= tx['amount'] + custom.fee
            if tx['type'] == 'post':
                if tx['pubkeys'][0] == pubkey:
                    balance -= tx['amount'] + custom.fee
        return balance

    if 'BrainWallet' in dic:
        dic['privkey'] = tools.det_hash(dic['BrainWallet'])
    elif 'privkey' not in dic:
        return "<p>You didn't type in your brain wallet.</p>"
    privkey = dic['privkey']
    pubkey = tools.privtopub(dic['privkey'])
    address = tools.make_address([pubkey], 1)
    balance = balance_(address, DB)
    doFunc = {
        'spend': (lambda dic: spend(float(dic['amount']), pubkey, privkey, dic[
            'to'], DB)),
        'post': (lambda dic: post(float(dic['amount']), pubkey, privkey, dic[
            'msg'], dic['parent'], DB)),
        'vote': (lambda dic: vote(float(dic['amount']), pubkey, privkey, dic[
            'location'], DB))
    }
    try:
        if 'do' in dic.keys(): doFunc[dic['do']](dic)
    except:
        pass
    out = empty_page
    out = out.format('<p>your address: ' + str(address) + '</p>{}')
    out = out.format('<p>current block: ' + str(DB['length']) + '</p>{}')
    out = out.format('<p>current balance is: ' + str(balance / 100000.0) +
                     '</p>{}')
    if balance > 0:
        out = out.format(
            easyForm(
                '/home', 'spend money', '''
        <input type="hidden" name="location" value="{}">
        <input type="hidden" name="do" value="spend">
        <input type="text" name="to" value="address to give to">
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(
                    dic['location'], privkey)))
        out = out.format(newline)
        out = out.format(
            easyForm(
                '/home', 'create post', '''
        <input type="hidden" name="location" value="{}">
        <input type="hidden" name="do" value="post">
        <input type="text" name="msg" value="message">
        <input type="hidden" name="parent" value="{}">        
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(
                    dic['location'], dic['location'], privkey)))
        out = out.format(newline)
    posts = map(lambda x: blockchain.db_get(x, DB), DB['posts'])
    zeroth_confirmations = filter(lambda tx: tx['type'] == 'post', DB['txs'])
    posts += zeroth_confirmations
    msg = blockchain.db_get(dic['location'], DB)
    txt = '''    <input type="hidden" name="privkey" value="{}">
                <input type="hidden" name="location" value="{}">
'''.format(privkey, '{}')
    out = out.format(
        easyForm('/home', 'Refresh: cd ./', txt.format(dic['location'])))
    out = out.format(
        easyForm('/home', 'Back: cd ../', txt.format(msg['parent'])))
    out = out.format(easyForm('/home', 'Root: cd /', txt.format('root')))
    out = out.format('<h2>' + display_msg(msg) + '</h2>{}')
    if balance > 0:
        out = out.format(
            easyForm(
                '/home', 'upvote/downvote',
                txt.format(dic['location']) + '''
    <input type="hidden" name="do" value="vote">
    <input type="text" name="amount" value="amount +/-">
    '''))
    out = out.format(display_posts(posts, dic['location'], 0))
    return out.format('')
Exemplo n.º 24
0
def main(brainwallet, pubkey_flag=False):
    DB=custom.DB
    tools.log('custom.current_loc: ' +str(custom.current_loc))
    print('starting full node')
    if not pubkey_flag:
        privkey=tools.det_hash(brainwallet)
        pubkey=tools.privtopub(privkey)
    else:
        pubkey=brainwallet
    a=tools.empty_peer()
    b=custom.peers
    #b[tools.getPublicIp()+':'+str(custom.port)]=a
    processes= [
        {'target': db.main,
         'args': (DB['heart_queue'], custom.database_name, tools.log, custom.database_port),
         'name': 'db'},
        {'target': auto_signer.mainloop,
         'args': (),
         'name': 'auto_signer'},        
        {'target': reward_collector.doit,
         'args': (),
         'name': 'auto_signer'},        
        #{'target':tools.heart_monitor,
        # 'args':(DB['heart_queue'], ),
        # 'name':'heart_monitor'},
        {'target': blockchain.main,
         'args': (DB,),
         'name': 'blockchain'},
        {'target': api.main,
         'args': (DB, DB['heart_queue']),
         'name': 'api'},
        {'target': peers_check.main,
         'args': (b, DB),
         'name': 'peers_check'},
        {'target': networking.serve_forever,
         'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
         'name': 'peer_recieve'}
    ]
    cmds=[]
    cmd=multiprocessing.Process(**processes[0])
    cmd.start()
    cmds.append(cmd)
    tools.log('starting '+cmd.name)
    time.sleep(4)
    b=tools.db_existence(0)
    #def empty_memoized(): return({'blockcount':-3000})
    if not b:
        tools.local_put('length', -1)
        tools.local_put('height', -1)
        tools.local_put('memoized_votes', {})
        tools.local_put('txs', [])
        tools.local_put('peers', {})
        tools.local_put('targets', {})
        tools.local_put('times', {})
        tools.local_put('mine', False)
        tools.local_put('my_sign_txs', {})#empty_memoized())
        tools.local_put('secrets', {})
        money=db.default_entry()
        money['amount']+=custom.all_money
        tools.db_put(custom.creator, money)
    tools.local_put('stop', False)
    tools.log('stop: ' +str(tools.local_get('stop')))
    for process in processes[1:]:
        cmd=multiprocessing.Process(**process)
        cmd.start()
        cmds.append(cmd)
        tools.log('starting '+cmd.name)
    if not pubkey_flag:
        tools.local_put('privkey', privkey)
    else:
        tools.local_put('privkey', 'Default')
    Address=tools.make_address([pubkey], 1)
    tools.local_put('address', Address)
    a=tools.db_proof(Address)
    tools.local_put('balance_proofs-1', a)
    tools.log('stop: ' +str(tools.local_get('stop')))
    while not tools.local_get('stop'):
        time.sleep(0.5)
    tools.log('about to stop threads')
    DB['heart_queue'].put('stop')
    for p in [[custom.port, '127.0.0.1'],
              [custom.api_port, '127.0.0.1']]:
        networking.connect('stop', p[0], p[1])
    cmds.reverse()
    for cmd in cmds[:-1]:
        cmd.join()
        tools.log('stopped a thread: '+str(cmd))
    time.sleep(2)
    networking.connect('stop', custom.database_port, '127.0.0.1')
    cmds[-1].join()
    tools.log('stopped a thread: '+str(cmds[-1]))
    tools.log('all threads stopped')
    sys.exit(0)
Exemplo n.º 25
0
        script=file(sys.argv[1],'r').read()
    except: script=''
    db = leveldb.LevelDB(custom.database_name)
    DB = {'stop':False,
          'mine':False,
          'db': db,
          'txs': [],
          'suggested_blocks': suggested_blocks,
          'suggested_txs': Queue.Queue(),
          'heart_queue': heart_queue,
          'memoized_votes':{},
          'peers_ranked':[],
          'brainwallet':'brain wallet',
          'diffLength': '0'}
    DB['privkey']=tools.det_hash(DB['brainwallet'])
    DB['pubkey']=tools.privtopub(DB['privkey'])
    DB['address']=tools.make_address([DB['pubkey']], 1)
    def len_f(i, DB):
        if not tools.db_existence(str(i), DB): return i-1
        return len_f(i+1, DB)
    DB['length']=len_f(0, DB)
    DB['diffLength']='0'
    if DB['length']>-1:
        DB['diffLength']=tools.db_get(str(DB['length']), DB)['diffLength']

    worker_tasks = [
        # Keeps track of blockchain database, checks on peers for new blocks and
        # transactions.
        #all these workers share memory DB
        #if any one gets blocked, then they are all blocked.
        {'target': api.main,
Exemplo n.º 26
0
listen_port = 8900
gui_port = 8700
version = "VERSION"
block_reward = 10**5
premine = 5 * 10**6
fee = 10**3
# Lower limits on what the "time" tag in a block can say.
mmm = 100
# Take the median of this many of the blocks.
# How far back in history do we look when we use statistics to guess at
# the current blocktime and difficulty.
history_length = 400
# This constant is selected such that the 50 most recent blocks count for 1/2 the
# total weight.
inflection = 0.985
download_many = 500  # Max number of blocks to request from a peer at the same time.
max_download = 50000
brainwallet = 'brain wallet'
privkey = tools.det_hash(brainwallet)
pubkey = tools.privtopub(privkey)
peers = [['localhost', 8901], ['localhost', 8902], ['localhost', 8903],
         ['localhost', 8904], ['localhost', 8905]]
hashes_per_check = 10**5


def blocktime(length):
    if length * block_reward < premine:
        return 30  # seconds
    else:
        return 60
Exemplo n.º 27
0
def main(brainwallet):
    print('starting truthcoin')
    heart_queue=multiprocessing.Queue()
    suggested_blocks=multiprocessing.Queue()
    #db = leveldb.LevelDB(custom.database_name)
    DB = {#'targets':{},
          #'times':{},
          #'db': db,
        'txs': [],
        'reward_peers_queue':multiprocessing.Queue(),
        'suggested_blocks': suggested_blocks,
        'suggested_txs': multiprocessing.Queue(),
        'heart_queue': heart_queue,
        'memoized_votes':{},
        #'peers_ranked':[],
        'diffLength': '0'}
    tools.db_put('peers_ranked', [])
    tools.db_put('targets', {})
    tools.db_put('times', {})
    tools.db_put('stop', False)
    tools.db_put('mine', False)
    DB['privkey']=tools.det_hash(brainwallet)
    DB['pubkey']=tools.privtopub(DB['privkey'])
    DB['address']=tools.make_address([DB['pubkey']], 1)
    def len_f(i, DB):
        if not tools.db_existence(str(i), DB): return i-1
        return len_f(i+1, DB)
    DB['length']=len_f(0, DB)
    DB['diffLength']='0'
    if DB['length']>-1:
        '''
        {'target': blockchain.suggestion_txs,
         'args': (DB,),
         'daemon': True},
        {'target': blockchain.suggestion_blocks,
         'args': (DB,),
         'daemon': True},
        '''
        #print('thing: ' +str(tools.db_get(str(DB['length']), DB)))
        DB['diffLength']=tools.db_get(str(DB['length']), DB)['diffLength']
    worker_tasks = [
        #all these workers share memory DB
        #if any one gets blocked, then they are all blocked.
        {'target': truthcoin_api.main,
         'args': (DB, heart_queue),
         'daemon':True},
        {'target': blockchain.main,
         'args': (DB,),
         'daemon': True},
        {'target': miner.main,
         'args': (DB['pubkey'], DB),
         'daemon': False},
        {'target': peers_check.main,
         'args': (custom.peers, DB),
         'daemon': True},
        {'target': networking.serve_forever,
         'args': (custom.port, lambda d: peer_recieve.main(d, DB), heart_queue, DB),
         'daemon': True}
    ]
    processes= [#this thread does NOT share memory with the rest.
        {'target':tools.heart_monitor,
         'args':(heart_queue, )}
    ]
    cmds=[]
    for process in processes:
        cmd=multiprocessing.Process(target=process['target'], args=process['args'])
        cmd.start()
        cmds.append(cmd)
    def start_worker_proc(**kwargs):
        daemon=kwargs.pop('daemon', True)
        proc = threading.Thread(**kwargs)
        proc.daemon = daemon
        proc.start()
        return proc
    workers = [start_worker_proc(**task_info) for task_info in worker_tasks]
    while not tools.db_get('stop'):
        time.sleep(0.5)
    tools.log('about to stop threads')
    DB['heart_queue'].put('stop')
    for worker in workers:
        tools.log('stopped a thread')
        worker.join()
    for cmd in cmds:
        tools.log('stopped a thread')
        cmd.join()
    #del DB['db']
    tools.log('all threads stopped')
    sys.exit(1)
Exemplo n.º 28
0
def main(brainwallet):
    print('starting truthcoin')
    heart_queue = multiprocessing.Queue()
    suggested_blocks = multiprocessing.Queue()
    #db = leveldb.LevelDB(custom.database_name)
    DB = {  #'targets':{},
        #'times':{},
        #'db': db,
        'txs': [],
        'reward_peers_queue': multiprocessing.Queue(),
        'suggested_blocks': suggested_blocks,
        'suggested_txs': multiprocessing.Queue(),
        'heart_queue': heart_queue,
        'memoized_votes': {},
        #'peers_ranked':[],
        'diffLength': '0'
    }
    tools.db_put('peers_ranked', [])
    tools.db_put('targets', {})
    tools.db_put('times', {})
    tools.db_put('stop', False)
    tools.db_put('mine', False)
    DB['privkey'] = tools.det_hash(brainwallet)
    DB['pubkey'] = tools.privtopub(DB['privkey'])
    DB['address'] = tools.make_address([DB['pubkey']], 1)

    def len_f(i, DB):
        if not tools.db_existence(str(i), DB): return i - 1
        return len_f(i + 1, DB)

    DB['length'] = len_f(0, DB)
    DB['diffLength'] = '0'
    if DB['length'] > -1:
        '''
        {'target': blockchain.suggestion_txs,
         'args': (DB,),
         'daemon': True},
        {'target': blockchain.suggestion_blocks,
         'args': (DB,),
         'daemon': True},
        '''
        #print('thing: ' +str(tools.db_get(str(DB['length']), DB)))
        DB['diffLength'] = tools.db_get(str(DB['length']), DB)['diffLength']
    worker_tasks = [
        #all these workers share memory DB
        #if any one gets blocked, then they are all blocked.
        {
            'target': truthcoin_api.main,
            'args': (DB, heart_queue),
            'daemon': True
        },
        {
            'target': blockchain.main,
            'args': (DB, ),
            'daemon': True
        },
        {
            'target': miner.main,
            'args': (DB['pubkey'], DB),
            'daemon': False
        },
        {
            'target': peers_check.main,
            'args': (custom.peers, DB),
            'daemon': True
        },
        {
            'target':
            networking.serve_forever,
            'args':
            (custom.port, lambda d: peer_recieve.main(d, DB), heart_queue, DB),
            'daemon':
            True
        }
    ]
    processes = [  #this thread does NOT share memory with the rest.
        {
            'target': tools.heart_monitor,
            'args': (heart_queue, )
        }
    ]
    cmds = []
    for process in processes:
        cmd = multiprocessing.Process(target=process['target'],
                                      args=process['args'])
        cmd.start()
        cmds.append(cmd)

    def start_worker_proc(**kwargs):
        daemon = kwargs.pop('daemon', True)
        proc = threading.Thread(**kwargs)
        proc.daemon = daemon
        proc.start()
        return proc

    workers = [start_worker_proc(**task_info) for task_info in worker_tasks]
    while not tools.db_get('stop'):
        time.sleep(0.5)
    tools.log('about to stop threads')
    DB['heart_queue'].put('stop')
    for worker in workers:
        tools.log('stopped a thread')
        worker.join()
    for cmd in cmds:
        tools.log('stopped a thread')
        cmd.join()
    #del DB['db']
    tools.log('all threads stopped')
    sys.exit(1)
Exemplo n.º 29
0
       ['192.241.212.114', 80]]

def hash_(x): return hashlib.sha256(x).hexdigest()
database_name='DB.db'
listen_port=8900
gui_port=8700
version="VERSION"
block_reward=10**5
premine=5*10**6
fee=10**3
mmm=100#lower limits on what
#the "time" tag in a block can say. Take the median
#of this many of the blocks.
history_length=400#how far back in history do
#we look when we use statistics to guess at 
#the current blocktime and difficulty.
inflection=0.985#This constant is selected such 
#that the 50 most recent blocks count for 1/2 the 
#total weight.
download_many=20#max number of blocks to request
#from a peer at the same time.
max_download=50000
privkey=tools.det_hash(brainwallet)
pubkey=tools.privtopub(privkey)
hashes_per_check=10**5
def blocktime(length):
    if length*block_reward<premine:
        return 30
    else:
        return 60
Exemplo n.º 30
0
def home(DB, dic):

    def display_msg(msg): 
        try: return str(msg['msg'])+' : '+str(msg['reputation']/100000.0)
        except: return str(msg['msg'])+' : '+str(msg['amount']/100000.0)
    def display_posts(posts, parent, tabs):
        out='{}'
        if tabs>2: return out
        for pos in posts:
            id_=transactions.postid(pos)
            if pos['parent']==parent:
                bumper='<div class="contentcontainer med left" style="margin-left: '+str(100*tabs)+'px;"><p>{}</p></div>'
                if pos in zeroth_confirmations:
                    print('pos: ' +str(pos))
                    out=out.format(bumper.format(display_msg(pos))+'{}')
                else:
                    txt=bumper.format(easyForm('/home', display_msg(pos), '''
                    <input type="hidden" name="location" value="{}">
                    <input type="hidden" name="parent" value="{}">
                    <input type="hidden" name="privkey" value="{}">'''.format(id_, id_,privkey))).format('')+'{}'
                    out=out.format(txt)
                out=out.format(display_posts(posts, id_, tabs+1))
        return out
    def balance_(address, DB):
        balance=blockchain.db_get(address, DB)['amount']
        for tx in DB['txs']:
            if tx['type'] == 'spend':
                if tx['to'] == address:
                    balance += tx['amount']
                if tx['pubkeys'][0] == pubkey:
                    balance -= tx['amount'] + custom.fee
            if tx['type'] == 'post':
                if tx['pubkeys'][0] == pubkey:
                    balance -= tx['amount'] + custom.fee
        return balance
    if 'BrainWallet' in dic:
        dic['privkey']=tools.det_hash(dic['BrainWallet'])
    elif 'privkey' not in dic:
        return "<p>You didn't type in your brain wallet.</p>"
    privkey=dic['privkey']
    pubkey=tools.privtopub(dic['privkey'])
    address=tools.make_address([pubkey], 1)
    balance=balance_(address, DB)
    doFunc={'spend': (lambda dic: spend(float(dic['amount']), pubkey, privkey, dic['to'], DB)),
            'post': (lambda dic: post(float(dic['amount']), pubkey, privkey, dic['msg'], dic['parent'], DB)),
            'vote': (lambda dic: vote(float(dic['amount']), pubkey, privkey, dic['location'], DB))}
    try: 
        if 'do' in dic.keys(): doFunc[dic['do']](dic)
    except: pass
    out=empty_page
    out=out.format('<p>your address: ' +str(address)+'</p>{}')
    out=out.format('<p>current block: ' +str(DB['length'])+'</p>{}')
    out=out.format('<p>current balance is: ' +str(balance/100000.0)+'</p>{}')
    if balance>0:
        out=out.format(easyForm('/home', 'spend money', '''
        <input type="hidden" name="location" value="{}">
        <input type="hidden" name="do" value="spend">
        <input type="text" name="to" value="address to give to">
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(dic['location'], privkey)))    
        out=out.format(newline)
        out=out.format(easyForm('/home', 'create post', '''
        <input type="hidden" name="location" value="{}">
        <input type="hidden" name="do" value="post">
        <input type="text" name="msg" value="message">
        <input type="hidden" name="parent" value="{}">        
        <input type="text" name="amount" value="amount to spend">
        <input type="hidden" name="privkey" value="{}">'''.format(dic['location'], dic['location'], privkey)))
        out=out.format(newline)
    posts=map(lambda x: blockchain.db_get(x, DB), DB['posts'])
    zeroth_confirmations=filter(lambda tx: tx['type']=='post', DB['txs'])
    posts+=zeroth_confirmations
    msg=blockchain.db_get(dic['location'], DB)
    txt='''    <input type="hidden" name="privkey" value="{}">
                <input type="hidden" name="location" value="{}">
'''.format(privkey, '{}')
    out=out.format(easyForm('/home', 'Refresh: cd ./', txt.format(dic['location'])))
    out=out.format(easyForm('/home', 'Back: cd ../', txt.format(msg['parent'])))
    out=out.format(easyForm('/home', 'Root: cd /', txt.format('root')))
    out=out.format('<h2>'+display_msg(msg)+'</h2>{}')
    if balance>0: out=out.format(easyForm('/home', 'upvote/downvote', txt.format(dic['location'])+'''
    <input type="hidden" name="do" value="vote">
    <input type="text" name="amount" value="amount +/-">
    '''))
    out=out.format(display_posts(posts, dic['location'], 0))
    return out.format('')
Exemplo n.º 31
0
    db = leveldb.LevelDB(custom.database_name)
    DB = {
        'stop': False,
        'mine': False,
        'db': db,
        'txs': [],
        'suggested_blocks': suggested_blocks,
        'suggested_txs': Queue.Queue(),
        'heart_queue': heart_queue,
        'memoized_votes': {},
        'peers_ranked': [],
        'brainwallet': 'brain wallet',
        'diffLength': '0'
    }
    DB['privkey'] = tools.det_hash(DB['brainwallet'])
    DB['pubkey'] = tools.privtopub(DB['privkey'])
    DB['address'] = tools.make_address([DB['pubkey']], 1)

    def len_f(i, DB):
        if not tools.db_existence(str(i), DB): return i - 1
        return len_f(i + 1, DB)

    DB['length'] = len_f(0, DB)
    DB['diffLength'] = '0'
    if DB['length'] > -1:
        DB['diffLength'] = tools.db_get(str(DB['length']), DB)['diffLength']

    worker_tasks = [
        # Keeps track of blockchain database, checks on peers for new blocks and
        # transactions.
        #all these workers share memory DB