def test_mine_blocks_on_ledger(monkeypatch):
""" test mining blocks """
mock_ledger = Ledger('foo')
mock_miner = Miner('foominer', mock_ledger)
mock_miner_2 = Miner('barminer', mock_ledger)
mock_miners = [mock_miner, mock_miner_2]
mock_ledger.transaction_sequence = 256
mine_blocks_on_ledger(mock_ledger, mock_miners, 10)
def create_users_and_ledger():
""" Create the users and ledger """
monies = Ledger('monies')
alice = User('Alice', monies)
bob = Miner('Bob', monies)
jon = User('Jon', monies)
howard = User('Howard', monies)
rocky = Miner('Rocky', monies)
# using an anon user for creating an initial balance
anon = User('Anon', monies)
users = [alice, jon, howard]
miners = [rocky, bob]
return (monies, anon, users, miners)
def test_mining_one_block_one_miner(self):
# block chain size is set to 5
miner_node = Miner()
user_node1 = Client()
user_node2 = Client()
user_node3 = Client()
tx1 = user_node1.generate_tx(
[(user_node2.public_key, 5)],
user_node1.get_random_input().get_transaction_hash(), 1)
miner_node.add_transaction(tx1)
tx2 = user_node1.generate_tx(
[(user_node3.public_key, 5)],
user_node1.get_random_input().get_transaction_hash(), 1)
miner_node.add_transaction(tx2)
tx3 = user_node2.generate_tx(
[(user_node3.public_key, 5)],
user_node2.get_random_input().get_transaction_hash(), 1)
miner_node.add_transaction(tx3)
tx4 = user_node2.generate_tx(
[(user_node1.public_key, 5)],
user_node2.get_random_input().get_transaction_hash(), 1)
miner_node.add_transaction(tx4)
tx5 = user_node3.generate_tx(
[(user_node1.public_key, 5)],
user_node3.get_random_input().get_transaction_hash(), 1)
miner_node.add_transaction(tx5)
self.assertTrue(miner_node.is_mining())
def __init__(self, public_key, private_key):
# save inputs
self.private_key = private_key
self.public_key = public_key
self.public_key_string = public_key.exportKey().decode("utf-8")
# build wallet
self.wallet = Wallet(self.public_key_string)
# register miner
pseudonym = resolve_pseudonym(self.public_key_string)
if pseudonym == "":
pseudonym = input("\nChoose a pseudonym: ")
else:
print(
"\nThis key has already been registered.\nRegistered pseudonym: "
+ pseudonym)
self.miner = Miner(pseudonym, self.public_key_string)
self.s = Serializer()
# build menu
self.menu = "\nchoose an number:"
self.menu += "\n1.) mine"
self.menu += "\n2.) check balance"
self.menu += "\n3.) make transaction"
self.menu += "\nchoice: "
def report(self, show_flag: bool = True)\
-> Dict[str, Dict[str, Dict[str, float]]]:
"""
:param show_flag: if True, output reports to a console
:return: reports for all, unknown only and known only NEs
{'all': {'NELABEL1': {'precision': 0.000,
'recall': 0.000,
'f1_score': 0.00},
'NELABEL2': {'precision': ...},
...
'unknown': ..., 'known': ..., 'misses': ...
}}
"""
sentences = self._dataset.get_sentences('test')
known_words = self._dataset.known_NEs()
predicts = self._model.predict_all(self.test_data[0])
miner = Miner(self.test_data[1], predicts, sentences, known_words)
return {
'all': miner.default_report(show_flag),
'unknown': miner.unknown_only_report(show_flag),
'known': miner.known_only_report(show_flag),
'misses': miner.return_miss_labelings(),
'seg': {
type_: miner.segmentation_score(type_, show_flag)
for type_ in ['all', 'unknown', 'known']
}
}
def __init__(self):
"""
Initialize the servers and miner required for a peer to peer node to operate.
"""
self.node_id = randbits(32) # Create a unique ID for this node
self.node_pool = NodePool(self.node_id, 30, 105)
self.miner = Miner()
self.miner.mine_event.append(self.block_mined)
self.heartbeat = p2p.Heartbeat(Node.REQUEST_PORT, 30, self.node_id)
router = RequestRouter(self)
router.handlers[request_pb2.BLOB] = self.handle_blob
router.handlers[request_pb2.DISOVERY] = self.handle_discovery
router.handlers[request_pb2.MINED_BLOCK] = self.handle_mined_block
router.handlers[request_pb2.RESOLUTION] = self.handle_resolution
router.handlers[
request_pb2.BLOCK_RESOLUTION] = self.handle_block_resolution
self.tcp_router = server.TCPServer(Node.REQUEST_PORT, TCPRouter)
self.tcp_router.router = router
self.udp_router = server.UDPServer(Node.REQUEST_PORT, UDPRouter)
self.udp_router.router = router
self.input_server = server.TCPServer(9999, DataServer)
self.input_server.node = self
self.output_server = server.TCPServer(9998, OutputServer)
self.output_server.node = self
def main():
global root
parser = argparse.ArgumentParser()
parser.add_argument('--epsilon', type=float, default=0.9, help='the probability to choose from memories')
parser.add_argument('--memory_capacity', type=int, default=50000, help='the capacity of memories')
parser.add_argument('--target_replace_iter', type=int, default=100, help='the iter to update the target net')
parser.add_argument('--batch_size', type=int, default=16, help='sample amount')
parser.add_argument('--lr', type=float, default=0.001, help='learning rate')
parser.add_argument('--n_epochs', type=int, default=20000, help='training epoch number')
parser.add_argument('--n_critic', type=int, default=100, help='evaluation point')
parser.add_argument('--test', type=int, default=0, help='whether execute test')
parser.add_argument('--conv', type=int, default=0, help = 'choose between linear and convolution')
opt = parser.parse_args()
print(opt)
miner = Miner(opt.epsilon, opt.memory_capacity, opt.target_replace_iter, opt.batch_size, opt.lr, opt.conv)
miner.load_params('eval.pth')
global root
# create Tk widget
root = Tk()
# set program title
root.title("Minesweeper")
# create game instance
game = GUI(root)
def sub_func():
print('pray tell')
s = game.get_state()
a = miner.choose_action(s)
game.lclicked(a)
print(a)
root.after(1000, sub_func)
# run event loop
root.after(1000, sub_func)
root.mainloop()
def _run(self, base_path):
m = Miner([
detection.WordpressDetector(),
detection.Drupal7Detector(),
detection.Drupal8Detector(),
])
print(JSONEncoder().encode(m.mine(base_path)))
def newPopulation(self, miners_pop):
new_pop = []
soft_max = self.softmax()
for i in range(self.maxpop):
father = self.pickParent(miners_pop, soft_max)
mother = self.pickParent(miners_pop, soft_max)
if father.fitness() >= 1:
child = Miner(father.id_number, father.size, father.maze_grid,
father.path)
elif mother.fitness() >= 1:
child = Miner(mother.id_number, mother.size, mother.maze_grid,
mother.path)
else:
child = Miner.crossover(father, mother)
new_pop.append(child)
return new_pop
def predict_to_testset(self, trainer):
"""
predicting labels of test dataset
:param trainer: Neural Network Model
"""
iterator = trainer.testset.return_batch(trainer.batch_size)
vecs = trainer.testset
for i, data in enumerate(iterator):
with torch.no_grad():
word = vecs.WORD.vocab.vectors[data.word].to(trainer.device)
char = vecs.CHAR.vocab.vectors[data.char].to(trainer.device)
mask = data.word != 1
mask = mask.float().to(trainer.device)
x = {'word': word, 'char': char}
decode = trainer.model.decode(x, mask)
for pred, ans, c in zip(decode, data.label, data.char):
self._answers.append([trainer.testset.LABEL.vocab.itos[i]
for i in ans[:len(pred)]])
self._predicts.append([trainer.testset.LABEL.vocab.itos[i]
for i in pred])
self._sentences.append([trainer.testset.CHAR.vocab.itos[i]
for i in c[:len(pred)]])
self.miner = Miner(self._answers, self._predicts,
self._sentences, self._known_words)
def _correct_known_words(self, trainer):
"""
correcting known named entities (named entities in train dataset)
:param trainer: Neural Network Model
"""
train_iterator = trainer.trainset.return_batch(trainer.batch_size)
vecs = trainer.trainset
known_answer = []
known_sentence = []
for i, data in enumerate(train_iterator):
with torch.no_grad():
word = vecs.WORD.vocab.vectors[data.word].to(trainer.device)
char = vecs.CHAR.vocab.vectors[data.char].to(trainer.device)
mask = data.word != 1
mask = mask.float().to(trainer.device)
x = {'word': word, 'char': char}
decode = trainer.model.decode(x, mask)
for pred, ans, c in zip(decode, data.label, data.char):
known_answer.append([trainer.trainset.LABEL.vocab.itos[i]
for i in ans[:len(pred)]])
known_sentence.append([trainer.trainset.CHAR.vocab.itos[i]
for i in c[:len(pred)]])
miner = Miner(known_answer, [['']],
known_sentence, {'PRO': [], 'SHO': []})
self._known_words = miner.return_answer_named_entities()['unknown']
def test1():
"""
tests wallets without p2p network,
the test is using common database
for all wallets
"""
logger = Logger('test1')
logger.info('Test 1 starts')
block_chain_db = BlockChainDB(logger)
# creates two wallets in the system
wallet1 = Wallet.new_wallet(block_chain_db, logger)
wallet2 = Wallet.new_wallet(block_chain_db, logger)
# check that their initial value is 0
assert wallet1.balance == 0
assert wallet2.balance == 0
# creates the miner in the system
wallet3 = Wallet.new_wallet(block_chain_db, logger)
miner = Miner(wallet3)
# mine the genesis block and check the miner balance
miner.mine()
first_balance = miner.wallet.get_balance()
assert first_balance > 0
# transfer from the miner to wallet1
# and mine the new block
assert miner.wallet.create_transaction(miner.wallet.balance,
wallet1.address)
miner.mine()
# check the new balances
assert wallet1.get_balance() == first_balance
second_balance = miner.wallet.get_balance()
assert second_balance > 0
# creates new transactions from the miner
# and wallet1 to wallet2 and mine the new block
wallet1.create_transaction(wallet1.get_balance(), wallet2.address)
miner.wallet.create_transaction(second_balance, wallet2.address)
miner.mine()
# check the new balances
assert wallet2.get_balance() == (first_balance + second_balance)
assert miner.wallet.get_balance() > 0
# create new transaction that demands change
# and mine the new block
wallet2.create_transaction(first_balance + 1, wallet1.address)
miner.mine()
# check the balances
assert wallet2.get_balance() == second_balance - 1
assert not wallet2.create_transaction(second_balance, wallet1.address)
logger.info('Finish successfully test 1')
block_chain_db.close_connection()
def main():
i = 5
peers = [Miner.Peer("1270.0.0.1", 8880 + x) for x in range(0, i)]
miners = [
Miner("127.0.0.1", 8880 + x, str(x), peers, pow(10, 6))
for x in range(0, i)
]
bootserver = BootstrapServer.boot(peers)
def newMiner(self, label):
if label in self.nodes:
raise ValueError(
"A node labelled '{}' already exists.".format(label))
newNode = Miner(label)
newNode.addPeer(self.relayNode)
self.nodes[label] = newNode
def new_miners_join(self):
"""
Arrival process is modeled as a poisson process, with mean arrival set to 3 miners per block/round.
The long term growth of the network is steady under this model.
"""
num_new_miners = poisson(self.new_miner_rate)
len_miner_set = len(self.M)
for i in range(len_miner_set, len_miner_set + num_new_miners):
self.M.add(Miner(ID=i))
def main(self):
# initiate block chain with num of zero that we want for proof of work
num_of_zero = 5
block_chain = BlockChain(num_of_zero)
miner = Miner(block_chain.hash_processor, block_chain.num_of_zero)
block_count = 0
while block_count < 5:
transaction_list = []
# generate random transaction
num_of_transaction = randint(1, 4)
for i in range(num_of_transaction):
from_id = randint(1, 100)
to_id = randint(1, 100)
amount = randint(200, 1000)
transaction = Transaction(from_id, to_id, amount)
transaction_list.append(transaction)
# ask miner to get new block to wrap transactions
# miner will do brute force in order to get the appropriate hash
block = miner.get_new_block(transaction_list,
block_chain.get_prev_hash())
# add to block_chain
# block chain will verify the block
block_chain.add_block(block)
# print calculated hash value to user
# to make sure right number of zero in the hash
hash_val = block_chain.hash_processor.calculate_hash(
block.get_hash_num())
print("block number %d" % (block_count + 1, ))
print("hash value : " + str(hash_val))
print("generated block : " + str(block))
print()
block_count += 1
# check mutation validation
# first should be valid
print(block_chain.check_is_valid())
# save current value and change the amount to new one
prev_amount = block_chain.blocks[1].transaction_list[0].amount
block_chain.blocks[1].transaction_list[0].amount = 100800
# check validity again, should be false
print(block_chain.check_is_valid())
# change it to original value
# should be valid again
block_chain.blocks[1].transaction_list[0].amount = prev_amount
print(block_chain.check_is_valid())
def main():
chain_mgr.chain.build_chain(dao.get_chain())
if sys.argv[1] == 'miner':
miner = Miner(chain_mgr, peer_mgr)
app.add_task(miner.start)
app.add_task(sync_chain)
app.add_task(advertise_self)
app.add_task(chain_mgr.start)
app.add_task(peer_mgr.start)
app.run(host='0.0.0.0', port=5001)
def add_miner(self):
miner_id = str(uuid.uuid4())
# make sure miner_id is unique, keep generating new uuid until so
while miner_id in self.miners:
miner_id = str(uuid.uuid4())
new_miner = Miner(id=miner_id)
self.miners[miner_id] = new_miner
return new_miner
def known_NEs(self):
"""
get Named Entities in training data
:return:
"""
sentences = self.get_sentences('train')
labels = self.get_labels('train')
m = Miner(labels, labels, sentences)
return m.return_answer_named_entities()['unknown']
def newNode(self, label):
if label in self.nodes:
raise ValueError(
"A node labelled '{}' already exists.".format(label))
newNode = Miner(label)
newNode.addPeer(
self.relayNode) # relayNode will hear but not send out txs/blocks
self.nodes[label] = newNode
def main():
miner = Miner(current_state=EnterMineAndDigForNugget(),
location=Locations.SHACK)
wife = Wife(current_state=DoHouseWork(), location=Locations.SHACK)
miner.other_entity = wife
wife.other_entity = miner
for i in range(0, 30):
miner.update()
wife.update()
def standard(miners_number=20, days=10):
# Convert simulation days to seconds
simulation_time = moment.get_seconds(days)
try:
clear_db()
except ConnectionError:
return -1
# Store in redis the simulation event names
configure_event_names([
Miner.BLOCK_REQUEST, Miner.BLOCK_RESPONSE, Miner.BLOCK_NEW,
Miner.HEAD_NEW
])
# Create simpy environment
env = simpy.Environment()
store = simpy.FilterStore(env)
# Create the seed block
seed_block = Block(None, 0, env.now, -1, 0, 1)
hashrates = numpy.random.dirichlet(numpy.ones(miners_number), size=1)
# Create miners
miners = []
# This dict is used to store the connections between miners, so they are not created twice
connections = dict()
for i in range(0, miners_number):
miner = Miner(env, store, hashrates[0, i] * Miner.BLOCK_RATE,
Miner.VERIFY_RATE, seed_block)
miners.append(miner)
connections[miner] = dict()
# Randomly connect miners
for i, miner in enumerate(miners):
miner_connections = numpy.random.choice([True, False],
miners_number)
for j, miner_connection in enumerate(miner_connections):
# Onlye create connection if miner is not self and connection does not already exist
if i != j and miner_connection == True and j not in connections[
miner] and i not in connections[miners[j]]:
# Store connection so its not created twice
connections[miner][j] = True
connections[miners[j]][i] = True
Miner.connect(miner, miners[j])
for miner in miners:
miner.start()
start = time.time()
# Start simulation until limit. Time unit is seconds
env.run(until=simulation_time)
end = time.time()
print("Simulation took: %1.4f seconds" % (end - start))
# Store in redis simulation days
store_days(days)
# After simulation store every miner head, so their chain can be built again
for miner in miners:
r.hset("miners:" + repr(miner.id), "head", miner.chain_head)
# Notify simulation ended
r.publish(Simulator.PUBSUB_CHANNEL, Simulator.SIMULATION_ENDED)
return 0
def addNodes(self, numMiners, numFullNodes):
"""Add Nodes to network"""
numNodes = numFullNodes + numMiners
"""Degree of network graph. Degree >= n/2 guarantees a connected graph"""
degree = numNodes // 2 + 1
for identifier in range(numNodes):
"""Possible neighbours are [0, 1, ... i-1, i+1, ... n]"""
possibleNeighbours = list(range(identifier)) + list(
range(identifier + 1, numNodes))
"""Generate a random sample of size degree without replacement from possible neighbours"""
randNeighbour = np.random.choice(possibleNeighbours,
size=degree,
replace=False)
neighbourList = [
"M%d" % x if x < numMiners else "F%d" % (x - numMiners)
for x in randNeighbour
]
"""Generate a location of the node"""
location = np.random.choice(self.locations, size=1)[0]
self.data["locationDist"][location] += 1
if identifier < numMiners:
self.miners["M%d" % identifier] = Miner(
"M%d" % identifier,
self.env,
neighbourList,
self.pipes,
self.nodes,
location,
self.data,
self.params,
)
if bool(self.params["verbose"]):
print("%7.4f" % self.env.now + " : " +
"%s added at location %s with neighbour list %s" %
("M%d" % identifier, location, neighbourList))
else:
self.fullNodes["F%d" % (identifier - numMiners)] = FullNode(
"F%d" % (identifier - numMiners),
self.env,
neighbourList,
self.pipes,
self.nodes,
location,
self.data,
self.params,
)
if bool(self.params["verbose"]):
print("%7.4f" % self.env.now + " : " +
"%s added at location %s with neighbour list %s" %
("F%d" % identifier, location, neighbourList))
self.nodes.update(self.miners)
self.nodes.update(self.fullNodes)
def main():
parser = argparse.ArgumentParser(
description='Generate a dependency map from multiple Maven'
'projects.')
parser.add_argument(
'directory',
nargs='+',
help='Directory to recursively search for build.properties files in.')
args = parser.parse_args()
miner = Miner(args.directory)
miner.run()
def mine(mineride, chain):
global timetaken
global blockarray
global miner
miner = Miner(chain)
minerID = miner.publickey.to_string().hex()
print ("Miner " +str(minerID)+" mining")
starttime = time.time()
block = miner.mine(chain)
elapsedtime = time.time() - starttime
timetaken.update({minerID:elapsedtime})
blockarray.append(block)
return block
def __init__(self):
self.peers = Peers()
self.blacklist = BlackList()
self.blockchain = BlockChain()
self.storage = BlockchainStorage()
self.mempool = Mempool()
self.miner = Miner()
self.ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
self.ctx.load_cert_chain("ca_certs/server.crt", "ca_certs/server.key")
self.ctx.load_verify_locations("ca_certs/client.crt")
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((HOST, PORT))
self.sock.listen(1)
logger.info(" Listening on {}:{}".format(HOST, PORT))
def init():
global tc
global miner
pvt_key = app.config.get('PVT_KEY')
tc = toychain.ToyChain(app.config['PORT'], pvt_key=pvt_key)
if not pvt_key:
filename = app.config['CONFIG_FILENAME']
with open(f'{filename}.py', 'a') as f:
f.write(f'PVT_KEY = \'\'\'{tc.get_pvt_key()}\'\'\'')
print(tc.get_address())
if app.config['MINING']:
miner = Miner(tc)
miner.start()
def test_last_block_hash():
"""
Test function for last block hash
"""
# Setup
mock_ledger = Ledger('monies')
mock_miner = Miner('Mock', mock_ledger)
mock_header = {'hdr': 'foo'}
mock_ledger.block_count = 1
mock_ledger.all_transactions.append(mock_header)
mock_message = mock_ledger.all_transactions[0]['hdr']
mock_nonce_attempts = 1000000
mock_difficulty = 4
mock_hash = cryptohash(mock_message, mock_nonce_attempts, mock_difficulty)
# Assert
assert mock_miner.last_block_hash() == mock_hash
def test_generate_transactions_on_ledger():
""" test generating transactions """
# Setup
mock_ledger = Ledger('foo')
mock_anon = User('Anon', mock_ledger)
mock_user = User('bar', mock_ledger)
mock_user_2 = User('foobar', mock_ledger)
mock_miner = Miner('foominer', mock_ledger)
mock_users = [mock_user, mock_user_2]
mock_miners = [mock_miner]
initial_value = 100
generate_initial_balance(mock_anon, mock_users, initial_value, 10)
ledger, users = generate_transactions_on_ledger(
mock_ledger, mock_users, 3, mock_miners, 10)
assert isinstance(ledger, Ledger)
for user in users:
assert isinstance(user, User)
def run_network():
q = Queue()
gb = Block.make_genesis_block()
chain = Chain()
chain.chain.append(gb)
chain_q.append(chain)
lock = threading.Lock()
transaction_threads = [
threading.Thread(target=make_transactions, args=(q, ))
for _ in range(16)
]
miners = [Miner(q, lock, chain_q) for _ in range(4)]
miner_threads = [threading.Thread(target=m.run) for m in miners]
for x in [*itertools.chain(miner_threads, transaction_threads)]:
x.start()
for m in [*itertools.chain(miner_threads, transaction_threads)]:
m.join()
