def main(args):
if args["serve"]:
from identities import alice_public_key
bank.issue(1000, alice_public_key)
serve()
elif args["ping"]:
response = send_message(ADDRESS, "ping", "", response=True)
print(response)
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
response = send_message(ADDRESS, "balance", public_key, response=True)
print(response)
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
# Fetch utxos available to spend
response = send_message(ADDRESS, "utxos", sender_public_key, response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key, amount)
# send to bank
response = send_message(ADDRESS, "tx", tx, response=True)
print(response)
else:
print("Invalid commands")
def main(args):
if args["serve"]:
global node
node = Node()
# TODO: mine genesis block
mine_genesis_block()
# Start server thread
server_thread = threading.Thread(target=serve, name="server")
server_thread.start()
# Start miner thread
#TODO: Figure out miner public key
miner_thread = threading.Thread(target=mine_forever,
args=[public_key],
name="miner")
miner_thread.start()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
else:
print("Invalid command")
def main(args):
if args["serve"]:
global node
node = Node()
# TODO mine genesis block
mine_genesis_block()
# start a server thread
server_thread = threading.Thread(target=serve, name="server")
server_thread.start()
miner_thread = threading.Thread(target=mine_forever, name="miner")
miner_thread.start()
elif args["ping"]:
response = send_message(ADDRESS, "ping", "", response=True)
print(response)
elif args["balance"]:
name = args["<name>"]
address = external_address(args["--node"])
public_key = user_public_key(name)
response = send_message(address, "balance", public_key, response=True)
print(response)
elif args["tx"]:
# Grab parameters
nodes = args["--node"].split(',')
addresses = list(map(external_address, nodes))
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
# Fetch utxos available to spend
response = send_message(addresses[0],
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
for addr in addresses:
response = send_message(addr, "tx", tx, response=True)
print(response)
else:
print("Invalid commands")
def main(args):
# Can't use 0.0.0.0 from the outside to talk to the docker containers
local_address = ("127.0.0.1", 5000)
if args["serve"]:
global bank
bank_id = int(os.environ["BANK_ID"])
bank = Bank(
id=bank_id,
private_key=bank_private_key(bank_id),
)
bank.airdrop(airdrop_tx())
bank.schedule_next_block()
serve()
elif args["ping"]:
response = send_message(local_address, "ping", "", response=True)
print(f"Response to ping: {response}")
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
response = send_message(local_address,
"balance",
public_key,
response=True)
print(f"Response to balance: {response}")
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
# Fetch utxos available to spend
response = send_message(local_address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to bank
response = send_message(local_address, "tx", tx, response=True)
print(f"Response to tx: {response}")
else:
print("Invalid commands")
def main(args):
if args["serve"]:
# HACK!
alice_public_key = user_public_key("alice")
bank.issue(1000, alice_public_key)
serve()
elif args["ping"]:
send_message("ping", "")
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
send_message("balance", public_key)
elif args["tx"]:
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_public_key = user_public_key(args["<to>"])
amount = int(args["<amount>"])
# fetch sender utxos
utxo_response = send_message("utxo", sender_public_key)
utxo = utxo_response["data"]
# prepare transaction
tx = prepare_simple_tx(utxo, sender_private_key, recipient_public_key,
amount)
# send transactions to bank
response = send_message("tx", tx)
print(response)
else:
print("invalid command")
def main(args):
if args["serve"]:
global bank
bank_id = int(os.environ["BANK_ID"])
bank = Bank(id=bank_id, private_key=bank_private_key(bank_id))
bank.airdrop(airdrop_tx())
bank.schedule_next_block()
serve()
elif args["ping"]:
send_message("ping", "")
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
send_message("balance", public_key)
elif args["tx"]:
sender_private_key = user_private_key(args["<from>"])
recipient_public_key = user_public_key(args["<to>"])
amount = int(args["<amount>"])
sender_public_key = sender_private_key.get_verifying_key()
utxo_response = send_message("utxo", sender_public_key)
utxo = utxo_response["data"]
tx = prepare_simple_tx(utxo, sender_private_key, recipient_public_key,
amount)
response = send_message("tx", tx)
print("response")
else:
print("invalid command")
def main(args):
if args["serve"]:
global bank
bank_id = int(os.environ["BANK_ID"])
bank = Bank(id=bank_id, private_key=bank_private_key(bank_id))
bank.airdrop(airdrop_tx())
bank.schedule_next_block()
serve()
elif args["ping"]:
response = send_message(ADDRESS, "ping", "", response=True)
print(response)
elif args["balance"]:
name = args["<name>"]
address = external_address(args["--node"])
public_key = user_public_key(name)
response = send_message(address, "balance", public_key, response=True)
print(response)
elif args["tx"]:
# Grab parameters
nodes = args["--node"].split(',')
addresses = list(map(external_address, nodes))
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
# Fetch utxos available to spend
response = send_message(addresses[0],
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to bank
for addr in addresses:
response = send_message(addr, "tx", tx, response=True)
print(response)
else:
print("Invalid commands")
def main(args):
if args["serve"]:
global bank
bank_id = int(os.environ["BANK_ID"])
bank = Bank(id=bank_id, private_key=bank_private_key(bank_id))
# Airdrop starting balances
bank.airdrop(airdrop_tx())
# Start producing blocks
bank.schedule_next_block()
serve()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to bank
send_message(address, "tx", tx)
else:
print("Invalid command")
def main(args):
if args["serve"]:
global node
node = Node()
serve()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
else:
print("Invalid command")
def main(args):
#parse command line args
if args["ping"]:
send_message("ping", "")
elif args["serve"]:
# issue some coins on server startup
alice_public_key = user_public_key("alice")
bank.issue(1000, alice_public_key)
serve()
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
balance_response = send_message("balance", public_key)
balance = balance_response["data"]
print(name + ": " + str(balance))
elif args["tx"]:
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_public_key = user_public_key(args["<to>"])
amount = int(args["<amount>"])
# fetch sender utxo
utxo_response = send_message("utxo", sender_public_key)
utxo = utxo_response["data"]
# prepare tx
tx = prepare_simple_tx(
utxo,
sender_private_key,
recipient_public_key,
amount,
)
# send tx as a message
tx_response = send_message("tx", tx)
print("Result: " + tx_response["data"])
else:
print("not a valid command")
# Start miner thread
miner_thread = threading.Thread(target=mine_forever, name="miner")
miner_thread.start()
elif args["ping"]:
address = external_address(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address, "utxos", sender_public_key, response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key, amount)
# send to node
send_message(address, "tx", tx)
if __name__ == "__main__":
args = docopt(__doc__)
print(args)
if args["ping"]:
ping()
elif args["serve"]:
alice_public_key = user_public_key("alice")
bank.issue(1000, alice_public_key)
serve()
elif args["balance"]:
name = args["<name>"]
public_key = user_public_key(name)
send_message("balance", public_key)
elif args["tx"]:
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_public_key = user_public_key(args["<to>"])
amount = int(args["<amount>"])
# fetch utxo
utxo_response = send_message("utxo", sender_public_key)
utxo = utxo_response["data"]
# prepare
tx = prepare_simple_tx(utxo, sender_private_key, recipient_public_key,
amount)
# send to bank
response = send_message("tx", tx)
print(response)
def main(args):
logger.info(os.environ)
if args["serve"]:
threading.current_thread().name = "main"
global node
hostname = os.environ['ME']
address = (hostname, PORT)
node = Node(address)
node_id = int(hostname[-1])
duration = 10 * node_id
time.sleep(duration)
# TODO: mine genesis block
mine_genesis_block()
# Start server thread
server_thread = threading.Thread(target=serve, name="server")
server_thread.start()
# Join the network
peers = {(p, PORT) for p in os.environ['PEERS'].split(',')}
try:
node.join_network(peers)
except:
# Peer not online yet
pass
# time for responses
time.sleep(1)
# Do initial block download
logger.info("starting ibd")
node.syncing = True
node.initial_block_download()
while node.syncing:
time.sleep(1)
# Start miner thread
miner_thread = threading.Thread(target=mine_forever, name="miner")
miner_thread.start()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
else:
print("Invalid command")
def main(args):
if args["serve"]:
# FIXME: needs coinbase
# genesis_block = Block(
# txns=[],
# prev_id=None,
# nonce=0,
# )
# node.chains.append([genesis_block])
# node.active_chain_index = 0
# Set up the node (for convience, alice get coinbase coins)
global node
peers = {(p, PORT) for p in os.environ['PEERS'].split(',')}
node = Node(peers)
genesis_coinbase = prepare_coinbase(
public_key=user_public_key("alice"), height=0)
unmined_genesis_block = Block(txns=[genesis_coinbase], prev_id=None)
mined_genesis_block = mine_block(unmined_genesis_block)
node.chains.append([mined_genesis_block])
node.active_chain_index = 0
node.add_tx_to_utxo_set(genesis_coinbase)
# Run the miner in a thread
node_id = int(os.environ["ID"])
mining_public_key = node_public_key(node_id)
thread = threading.Thread(target=mine_forever,
args=(mining_public_key, ))
thread.start()
serve()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
print(response["data"])
elif args["utxos"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "utxos", public_key, response=True)
print(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
print(tx)
else:
print("Invalid command")
def main(args):
if args["serve"]:
threading.current_thread().name = "main"
node_id = int(os.environ["ID"])
duration = 3 * node_id
logger.info(f"sleeping {duration}")
time.sleep(duration)
logger.info("waking up")
# Set up the node (for convience, alice get coinbase coins)
global node
address = (f"node{node_id}", PORT)
node = Node(address=address)
# Mine genesis block
mine_genesis_block(node, user_public_key("alice"))
# First thing, start server in another thread
server_thread = threading.Thread(target=serve, name="server")
server_thread.start()
# Join the network
peers = [(p, PORT) for p in os.environ['PEERS'].split(',')]
for peer in peers:
try:
node.connect(peer)
logger.info(f'Connected to "{peer[0]}"')
except:
logger.info(f'Node "{peer[0]} offline"')
# Do initial block download
logger.info("starting ibd")
node.initial_block_download()
# Run the miner in a thread
logger.info("starting miner")
node_id = int(os.environ["ID"])
mining_public_key = node_public_key(node_id)
miner_thread = threading.Thread(target=mine_forever,
args=(mining_public_key, ),
name="miner")
miner_thread.start()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
logger.info(response["data"])
elif args["utxos"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "utxos", public_key, response=True)
logger.info(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
logger.info(tx)
else:
logger.info("Invalid command")
def main(args):
if args["serve"]:
threading.current_thread().name = "main"
# FIXME: needs coinbase
# genesis_block = Block(
# txns=[],
# prev_id=None,
# nonce=0,
# )
# node.chains.append([genesis_block])
# node.active_chain_index = 0
node_id = int(os.environ["ID"])
duration = 5 * node_id
logger.info(f"sleeping {duration}")
time.sleep(duration)
logger.info("waking up")
# Set up the node (for convience, alice get coinbase coins)
global node
node = Node(node_id=node_id)
# Insert coinbase
# FIXME: this is a mess
genesis_coinbase = prepare_coinbase(
public_key=user_public_key("alice"), height=0)
unmined_genesis_block = Block(txns=[genesis_coinbase], prev_id=None)
mined_genesis_block = mine_block(unmined_genesis_block, step=1)
node.chains.append([mined_genesis_block])
node.active_chain_index = 0
node.add_tx_to_utxo_set(genesis_coinbase)
# First thing, start server in another thread
server_thread = threading.Thread(target=serve, name="server")
server_thread.start()
# Join the network
peers = {(p, PORT) for p in os.environ['PEERS'].split(',')}
# first one will fail b/c no peers yet.
try:
node.join_network(peers)
except:
pass
# Do initial block download
logger.info("starting ibd")
node.syncing = True
node.initial_block_download()
# Run the miner in a thread
logger.info("starting miner")
node_id = int(os.environ["ID"])
mining_public_key = node_public_key(node_id)
miner_thread = threading.Thread(target=mine_forever,
args=(mining_public_key, ),
name="miner")
miner_thread.start()
elif args["ping"]:
address = address_from_host(args["--node"])
send_message(address, "ping", "")
elif args["balance"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "balance", public_key, response=True)
logger.info(response["data"])
elif args["utxos"]:
public_key = user_public_key(args["<name>"])
address = external_address(args["--node"])
response = send_message(address, "utxos", public_key, response=True)
logger.info(response["data"])
elif args["tx"]:
# Grab parameters
sender_private_key = user_private_key(args["<from>"])
sender_public_key = sender_private_key.get_verifying_key()
recipient_private_key = user_private_key(args["<to>"])
recipient_public_key = recipient_private_key.get_verifying_key()
amount = int(args["<amount>"])
address = external_address(args["--node"])
# Fetch utxos available to spend
response = send_message(address,
"utxos",
sender_public_key,
response=True)
utxos = response["data"]
# Prepare transaction
tx = prepare_simple_tx(utxos, sender_private_key, recipient_public_key,
amount)
# send to node
send_message(address, "tx", tx)
logger.info(tx)
else:
logger.info("Invalid command")
