def genesis(pubkey):
    out = {'version': custom.version,
           'length': 0,
           'time': time.time(),
           'txs': [make_mint(pubkey)]}
    out = tools.unpackage(tools.package(out))
    return out

 def genesis(pubkey, DB):
     out={'version':custom.version,
          'length':0,
          'time':time.time(),
          'target':blockchain.target(DB),
          'txs':[make_mint(pubkey, DB)]}
     out=tools.unpackage(tools.package(out))
     return out

def db_get (n, DB): 
    n=str(n)
    if len(n)==130: n=tools.pub2addr(n)
    try:
        a=DB['db'].Get(n)
    except:
        error('here')
    return tools.unpackage(a)

def db_get(n, DB):
    n = str(n)
    try:
        return tools.unpackage(DB['db'].Get(n))
    except:
        db_put(n, {'count': 0, 'amount': 0}, DB)  # Everyone defaults with
        # having zero money, and having broadcast zero transcations.
        return db_get(n, DB)

 def make_block(prev_block, txs, pubkey, DB):
     leng=int(prev_block['length'])+1
     out={'version':custom.version,
          'txs':txs+[make_mint(pubkey, DB)],
          'length':leng,
          'time':time.time(),
          'target':blockchain.target(DB, leng),
          'prevHash':tools.det_hash(prev_block)}
     out=tools.unpackage(tools.package(out))
     return out

def db_get(n, DB): 
    n=str(n)
    if len(n)==130: 
        n=tools.pub2addr(n)
        try:
            a=DB['db'].Get(n)
        except:
            db_put(n, {'count':0, 'amount':0}, DB)#everyone defaults with having zero money, and having broadcast zero transcations.
            return db_get(n, DB)
    return tools.unpackage(DB['db'].Get(n))

def make_block(prev_block, txs, pubkey):
    leng = int(prev_block['length']) + 1

    out = {'version': custom.version,
           'txs': txs,  # dont forget to add coinbase transaction ;)
           'length': leng,
           'time': time.time(),
           'prevHash': tools.det_hash(prev_block)}
    out = tools.unpackage(tools.package(out))
    return out

def genesis(pubkey, DB):
    target_ = target.target()
    out = {'version': custom.version,
           'length': 0,
           'time': time.time(),
           'target': target_,
           'diffLength': blockchain.hexInvert(target_),
           'txs': [make_mint(pubkey, DB)]}
    out = tools.unpackage(tools.package(out))
    return out

 def genesis(pubkey, DB):
     target = blockchain.target(DB)
     out = {'version': custom.version,
            'length': 0,
            'time': time.time(),
            'target': target,
            'diffLength': blockchain.hexInvert(target),
            'txs': [make_mint(pubkey, DB)]}
     print('out: ' + str(out))
     out = tools.unpackage(tools.package(out))
     return out

def serve_forever(message_handler_func, PORT, queue):
    server = socket.socket()
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    server.bind(("127.0.0.1", PORT))
    server.listen(100)
    while True:
        client, addr = server.accept()
        (ip, port) = addr
        data = client.recv(MAX_MESSAGE_SIZE)
        # we could insert security checks here
        data = tools.unpackage(data)
        client.send(tools.package(message_handler_func(data, queue)))

 def make_block(prev_block, txs, pubkey, DB):
     leng=int(prev_block['length'])+1
     target=blockchain.target(DB, leng)
     diffLength=blockchain.hexSum(prev_block['diffLength'], blockchain.hexInvert(target))
     out={'version':custom.version,
          'txs':txs+[make_mint(pubkey, DB)],
          'length':leng,
          'time':time.time(),
          'diffLength':diffLength,
          'target':target,
          'prevHash':tools.det_hash(prev_block)}
     out=tools.unpackage(tools.package(out))
     return out

def main():
    info=sys.argv
    peer=['127.0.0.1', custom.basicd_port]
    p={'command':sys.argv[1:]}
    if len(p['command'])==0:
        p['command'].append(' ')
    response=networking.send_command(peer, p, 5)
    if tools.can_unpack(response):
        response=tools.unpackage(response)
    if type(response)==type({'a':1}):
        if 'error' in response:
            print('basiccoin is probably off. Use command: "python threads.py" to turn it on. (you may need to reboot it a couple times to get it working)')
    return(response)

def create_sign_tx():
    on_block=tools.local_get('length')+1
    if on_block==0:
        time.sleep(1)
        return{'error':'not ready'}
    r=tools.det_random(on_block)
    jackpots=[]
    address=tools.local_get('address')
    l=max(-1, on_block-1-(custom.long_time*2-custom.medium_time))
    election_block=tools.db_get(l+1)
    proof=tools.local_get('balance_proofs'+str(l))
    if 'root_hash' not in election_block:
        return({'error':'database changed'})
    a=tools.db_verify(election_block['root_hash'], address, proof)
    if a==False:
        #tools.log('election block: ' +str(election_block))
        #tools.log('proof: ' +str(proof))
        return({'error':'not valid proof'})
    old_balance=a['amount']
    M=custom.all_money
    for j in range(custom.jackpot_nonces):
        if tools.winner(old_balance, M, r, address, j):
            jackpots.append(j)
    if len(jackpots)>0:
        tx={'on_block':on_block, 'jackpots':jackpots, 'type':'sign', 'amount':M/3000/3}
        tx['B']=old_balance
        tx['proof']=proof
        if proof=='empty':
            time.sleep(1)
            return {'error':'not ready'}
        secrets=tools.local_get('secrets')
        if str(on_block) in secrets:
            secret=secrets[str(on_block)]
        else:
            secret=tools.unpackage(tools.package({'salt':str(random.random())+str(random.random()), 'entropy':random.randint(0,1)}))
            secrets[str(on_block)]=secret
            tools.local_put('secrets', secrets)
        tx['secret_hash']=tools.det_hash(secret)
        if on_block>0:
            block=tools.db_get(on_block-1)
            if 'amount' in block and block['amount']==0:
                return({'error':'database changed'})
            #tools.log('on_block: ' +str(a))
            tx['prev']=block['block_hash']
    else:
        tx= {'error':'no jackpots'}
    return tx

def buy_block(DB, args):
    gap=1#this should be an argument. 
    #we should also let the user delete as many blocks first as they want, to build a fork from a point in history.
    length=tools.local_get('length')
    prev_block=tools.db_get(length)
    txs=tools.local_get('txs')
    privkey=tools.local_get('privkey')
    height=tools.local_get('height')
    block=default_block(length+1, height+gap, txs+[sign(mint_tx(gap), privkey)])
    to_hash=''
    if length>-1: to_hash={'prev_hash':prev_block['block_hash'], 'txs':block['txs']}
    block['block_hash']=tools.det_hash(to_hash)
    block['root_hash']=tools.db_root()
    block=sign(block, privkey)
    block = tools.unpackage(tools.package(block))
    DB['suggested_blocks'].put(block)
    return block

def connect(msg, host, port):
    if len(msg) < 1 or len(msg) > MAX_MESSAGE_SIZE:
        print("wrong sized message")
        return
    s = socket.socket()
    try:
        s.settimeout(2)
        s.connect((str(host), int(port)))
        msg["version"] = custom.version
        s.send(tools.package(msg))
        response = s.recv(MAX_MESSAGE_SIZE)
        # print(response)
        return tools.unpackage(response)
    except Exception as e:
        # print('THE ERROR WAS: ' +str(e))
        # print('disconnect')
        return {"error": "error"}

def connect(msg, host, port):
    msg['version'] = custom.version
    msg = tools.package(msg)
    if len(msg) < 1 or len(msg) > MAX_MESSAGE_SIZE:
        print('wrong sized message')
        return
    s = socket.socket()
    try:
        s.settimeout(2)
        s.connect((str(host), int(port)))
        s.sendall(msg)
        response = s.recv(MAX_MESSAGE_SIZE)
        #print(response)
        return tools.unpackage(response)
    except Exception as e:
        #print('THE ERROR WAS: ' +str(e))
        #print('disconnect')
        return {'error': e}

def buy_block(DB, args):
    gap = 1  # this should be an argument.
    # we should also let the user delete as many blocks first as they want, to build a fork from a point in history.
    length = tools.local_get("length")
    prev_block = tools.db_get(length)
    txs = tools.local_get("txs")
    privkey = tools.local_get("privkey")
    height = tools.local_get("height")
    block = default_block(length + 1, height + gap, txs + [sign(mint_tx(gap), privkey)])
    to_hash = ""
    if length > -1:
        to_hash = {"prev_hash": prev_block["block_hash"], "txs": block["txs"]}
    block["block_hash"] = tools.det_hash(to_hash)
    block["root_hash"] = tools.db_root()
    block = sign(block, privkey)
    block = tools.unpackage(tools.package(block))
    DB["suggested_blocks"].put(block)
    return block

def connect(msg, host, port, response_time=1):
    if len(msg) < 1 or len(msg) > MAX_MESSAGE_SIZE:
        tools.log('wrong sized message')
        return('wrong size')
    s = socket.socket()
    s.setblocking(0)
    b=connect_socket(s, str(host), int(port))
    if not b: 
        s.close()
        return ({'error':'cannot connect: '+str(host)})
    msg['version'] = custom.version
    sendall(s, tools.package(msg))
    response=recvall(s, MAX_MESSAGE_SIZE, response_time)
    s.close()
    try:
        return tools.unpackage(response)
    except:
        pass
    if 'recvall timeout error' in response:
        return({'error':'cannot download: '+str(host)})

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

def serve_once(PORT, handler, heart_queue, server):
    heart_queue.put('server: '+str(PORT))
    time.sleep(0.1)
    try:
        client, addr = server.accept()
    except:
        return
    (ip, port) = addr
    peer=[str(ip), int(port)]
    try:
        data=recvall(client, MAX_MESSAGE_SIZE)
    except:
        client.close()
        return
    if type(data)==type('string'):
        data=tools.unpackage(data)
    data['peer']=peer
    try:
        sendall(client, tools.package(handler(data)))
    except:
        pass
    client.close()