def test_run_single_block_mock(self): b = Delegate(socket_base='ipc:///tmp/n2', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) gb = canonical.get_genesis_block() gb = canonical.dict_to_capnp_block(gb) # Put the genesis block in here so we start immediately b.nbn_inbox.q.append(gb) b.running = True # Add a single peer that we control b.parameters.sockets = {mnw1.verifying_key().hex(): 'ipc:///tmp/n1'} put_test_contract(self.client) b.work_inbox.work[mnw1.verifying_key().hex()] = get_tx_batch() async def stop(): await asyncio.sleep(1) b.running = False b.nbn_inbox.q.append(gb) loop = asyncio.get_event_loop() tasks = asyncio.gather(b.run(), stop()) loop.run_until_complete(tasks)
def test_acquire_work_if_no_one_connected_returns(self): d = Delegate(ctx=self.ctx, socket_base='ipc:///tmp/n1', constitution=constitution, wallet=dw1, overwrite=True) self.loop.run_until_complete(d.acquire_work())
def test_did_sign_block_false_if_no_pending_sbcs(self): b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) self.assertFalse(b.did_sign_block(None))
def make_network(masternodes, delegates, ctx, mn_min_quorum=2, del_min_quorum=2): mn_wallets = [Wallet() for _ in range(masternodes)] dl_wallets = [Wallet() for _ in range(delegates)] constitution = { 'masternodes': [mn.verifying_key().hex() for mn in mn_wallets], 'delegates': [dl.verifying_key().hex() for dl in dl_wallets], 'masternode_min_quorum': mn_min_quorum, 'delegate_min_quorum': del_min_quorum, } mns = [] dls = [] bootnodes = None node_count = 0 for wallet in mn_wallets: driver = BlockchainDriver(driver=InMemDriver()) # driver = IsolatedDriver() ipc = f'/tmp/n{node_count}' make_ipc(ipc) if bootnodes is None: bootnodes = [f'ipc://{ipc}'] mn = Masternode(wallet=wallet, ctx=ctx, socket_base=f'ipc://{ipc}', bootnodes=bootnodes, constitution=deepcopy(constitution), webserver_port=18080 + node_count, driver=driver) mns.append(mn) node_count += 1 for wallet in dl_wallets: driver = BlockchainDriver(driver=InMemDriver()) # driver = IsolatedDriver() ipc = f'/tmp/n{node_count}' make_ipc(ipc) dl = Delegate(wallet=wallet, ctx=ctx, socket_base=f'ipc://{ipc}', constitution=deepcopy(constitution), bootnodes=bootnodes, driver=driver) dls.append(dl) node_count += 1 return mns, dls
def test_execute_multiple_tx_in_batch_returns_correct_sbc(self): test_contract = ''' v = Variable() @construct def seed(): v.set('hello') @export def set(var): v.set(var) @export def get(): return v.get() ''' self.client.submit(test_contract, name='testing') tx = TransactionBuilder(sender='stu', contract='testing', function='set', kwargs={'var': 'howdy'}, stamps=100_000, processor=b'\x00' * 32, nonce=0) tx.sign(Wallet().signing_key()) tx.serialize() tx2 = TransactionBuilder(sender='stu', contract='testing', function='get', kwargs={}, stamps=100_000, processor=b'\x00' * 32, nonce=0) tx2.sign(Wallet().signing_key()) tx2.serialize() tx_batch = transaction_list_to_transaction_batch( [tx.struct, tx2.struct], wallet=Wallet()) w = Wallet() b = Delegate(socket_base='tcp://127.0.0.1', wallet=w, ctx=self.ctx) results = b.execute_work([(tx_batch.timestamp, tx_batch)]) # Test that there is a state change on the 1st tx tx = results[0].transactions[0] self.assertEqual(tx.state[0].key, b'testing.v') self.assertEqual(tx.state[0].value, b'"howdy"') self.assertEqual(results[0].inputHash, tx_batch.inputHash) self.assertEqual(results[0].prevBlockHash, b'\x00' * 32) self.assertEqual(results[0].signer, w.verifying_key())
def test_block_number_increments_properly(self): mock_master = ComplexMockMasternode( ctx=self.ctx, delegate_nbn='ipc:///tmp/n1/block_notifications', delegate_work='ipc:///tmp/n1/incoming_work', wallet=mnw1) d = Delegate(ctx=self.ctx, socket_base='ipc:///tmp/n1', constitution=constitution, wallet=dw1, overwrite=True) # d.nbn_inbox.verify = False d.work_inbox.verify = False d.running = True d.parameters.sockets = {mnw1.verifying_key().hex(): 'ipc:///tmp/n2'} async def run(): await asyncio.sleep(0.3) self.assertEqual(d.driver.latest_block_num, 0) await mock_master.send_new_block_to_socket() # Assert Block num 1 await asyncio.sleep(0.3) self.assertEqual(d.driver.latest_block_num, 1) await mock_master.send_to_work_socket() w = await mock_master.mn_agg.recv_multipart() b = canonical.get_genesis_block() b['blockNum'] = 2 await mock_master.send_new_block_to_socket(b) # Assert Block num 2 await asyncio.sleep(0.3) self.assertEqual(d.driver.latest_block_num, 2) d.nbn_inbox.stop() d.work_inbox.stop() d.stop() self.loop.stop() tasks = asyncio.gather(d.work_inbox.serve(), d.nbn_inbox.serve(), d.run(), run()) with suppress(RuntimeError): self.loop.run_until_complete(tasks)
def test_did_sign_block_false_if_missing_any_merkle_roots(self): b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) block = random_block() # Add one root but not the other b.pending_sbcs.add(block.subBlocks[0].merkleRoot) self.assertFalse(b.did_sign_block(block))
def test_environment_variables_are_working_as_they_should(self): test_contract = ''' a = Variable() b = Variable() c = Variable() @export def capture(): a.set(block_hash) b.set(block_num) c.set(now) ''' self.client.submit(test_contract, name='testing') tx = TransactionBuilder(sender='stu', contract='testing', function='capture', kwargs={}, stamps=100_000, processor=b'\x00' * 32, nonce=0) tx.sign(Wallet().signing_key()) tx.serialize() tx_batch = transaction_list_to_transaction_batch([tx.struct], wallet=Wallet()) w = Wallet() b = Delegate(socket_base='tcp://127.0.0.1', wallet=w, ctx=self.ctx) now = Datetime._from_datetime( datetime.utcfromtimestamp(tx_batch.timestamp)) results = b.execute_work([(tx_batch.timestamp, tx_batch)]) tx = results[0].transactions[0] a, b, c = tx.state self.assertEqual(a.key, b'testing.a') self.assertEqual( a.value, b'"0000000000000000000000000000000000000000000000000000000000000000"' ) self.assertEqual(b.key, b'testing.b') self.assertEqual(b.value, b'0') self.assertEqual(c.key, b'testing.c') self.assertEqual(c.value, encode(now).encode())
def test_process_nbn_updates_state_with_block_if_did_not_sign_block(self): b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) block = random_block() k = block.subBlocks[0].transactions[0].state[0].key v = block.subBlocks[0].transactions[0].state[0].value self.assertIsNone(b.client.raw_driver.get_direct(k)) b.process_block(block) self.assertEqual(b.client.raw_driver.get_direct(k), v)
def test_process_nbn_commits_changes_if_did_sign_block(self): b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) block = random_block() # Add one root but not the other b.pending_sbcs.add(block.subBlocks[0].merkleRoot) b.pending_sbcs.add(block.subBlocks[1].merkleRoot) b.client.raw_driver.set('A', 'B') self.assertIsNone(b.client.raw_driver.get_direct('A')) b.process_block(block) self.assertEqual(b.client.raw_driver.get(b'A'), 'B')
def join_network(args): assert args.node_type == 'masternode' or args.node_type == 'delegate', \ 'Provide node type as "masternode" or "delegate"' sk = bytes.fromhex(args.key) wallet = Wallet(seed=sk) const = resolve_constitution(args.constitution) mn_seed = f'tcp://{args.mn_seed}' ip_str = requests.get('http://api.ipify.org').text socket_base = f'tcp://{ip_str}' # Setup Environment # CURR_DIR = pathlib.Path(os.getcwd()) # os.environ['PKG_ROOT'] = str(CURR_DIR.parent) # os.environ['CIL_PATH'] = os.getenv('PKG_ROOT') + '/cilantro_ee' if args.node_type == 'masternode': # Start mongo start_mongo() n = Masternode(wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, constitution=const, webserver_port=args.webserver_port, mn_seed=mn_seed) elif args.node_type == 'delegate': start_mongo() n = Delegate(wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, constitution=const, mn_seed=mn_seed) loop = asyncio.get_event_loop() asyncio. async (n.start()) loop.run_forever()
def test_execute_work_single_transaction(self): test_contract = ''' v = Variable() @construct def seed(): v.set('hello') @export def set(var): v.set(var) @export def get(): return v.get() ''' self.client.submit(test_contract, name='testing') tx = TransactionBuilder(sender='stu', contract='testing', function='set', kwargs={'var': 'jeff'}, stamps=100_000, processor=b'\x00' * 32, nonce=0) tx.sign(Wallet().signing_key()) tx.serialize() tx_batch = transaction_list_to_transaction_batch([tx.struct], wallet=Wallet()) b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution) b.execute_work([(1, tx_batch)])
def test_build_sbc_from_work_results(self): test_contract = ''' v = Variable() @construct def seed(): v.set('hello') @export def set(var): v.set(var) @export def get(): return v.get() ''' print('ok') self.client.submit(test_contract, name='testing') print('here') tx = TransactionBuilder(sender='stu', contract='testing', function='set', kwargs={'var': 'jeff'}, stamps=100_000, processor=b'\x00' * 32, nonce=0) tx.sign(Wallet().signing_key()) tx.serialize() tx_batch = transaction_list_to_transaction_batch([tx.struct], wallet=Wallet()) b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, constitution=constitution) print(sbc)
def test_acquire_work_for_one_master_returns_a_single_tx_batch(self): mock_master = ComplexMockMasternode( ctx=self.ctx, delegate_nbn='ipc:///tmp/n1/block_notifications', delegate_work='ipc:///tmp/n1/incoming_work', wallet=mnw1) d = Delegate(ctx=self.ctx, socket_base='ipc:///tmp/n1', constitution=constitution, wallet=dw1, overwrite=True) d.running = True d.parameters.sockets = {mnw1.verifying_key().hex(): 'ipc:///tmp/n2'} args_1 = ('hi', 'hello') args_2 = ('howdy', 'yo') args_3 = ('yeehaw', 'p') mock_master.tx_batcher.queue.extend([ make_tx(mnw1.verifying_key(), *args_1), make_tx(mnw1.verifying_key(), *args_2), make_tx(mnw1.verifying_key(), *args_3), ]) async def stop(): await asyncio.sleep(0.3) d.work_inbox.stop() tasks = asyncio.gather(d.work_inbox.serve(), mock_master.send_to_work_socket(), d.acquire_work(), stop()) _, _, r, _ = self.loop.run_until_complete(tasks) print(r)
def test_acquire_work_returns_empty_self_signed_tx_batches_if_timeout_hit( self): mock_master = ComplexMockMasternode( ctx=self.ctx, delegate_nbn='ipc:///tmp/n1/block_notifications', delegate_work='ipc:///tmp/n1/incoming_work', wallet=mnw1) mock_master_2 = ComplexMockMasternode( ctx=self.ctx, delegate_nbn='ipc:///tmp/n1/block_notifications', delegate_work='ipc:///tmp/n1/incoming_work', wallet=mnw2, ipc='n3') d = Delegate(ctx=self.ctx, socket_base='ipc:///tmp/n1', constitution=constitution2, wallet=dw1, overwrite=True) d.running = True d.parameters.sockets = { mnw1.verifying_key().hex(): 'ipc:///tmp/n2', mnw2.verifying_key().hex(): 'ipc:///tmp/n3', mnw3.verifying_key().hex(): 'ipc:///' } args_1 = ('hi', 'hello') args_2 = ('howdy', 'yo') args_3 = ('yeehaw', 'p') mock_master.tx_batcher.queue.extend([ make_tx(mnw1.verifying_key(), *args_1), make_tx(mnw1.verifying_key(), *args_2), make_tx(mnw1.verifying_key(), *args_3), ]) ### TXS for master 2 args_4 = ('aaa', 'bbb') args_5 = ('123', 'xxx') args_6 = ('456', 'zzz') mock_master_2.tx_batcher.queue.extend([ make_tx(mnw2.verifying_key(), *args_4), make_tx(mnw2.verifying_key(), *args_5), make_tx(mnw2.verifying_key(), *args_6), ]) async def stop(): await asyncio.sleep(0.3) d.work_inbox.stop() tasks = asyncio.gather(d.work_inbox.serve(), mock_master.send_to_work_socket(), mock_master_2.send_to_work_socket(), d.acquire_work(), stop()) _, _, _, r, _ = self.loop.run_until_complete(tasks) print(r[0]) print(r[1]) print(r[2])
def setup_node(): node_type = '' while node_type not in ['M', 'D']: node_type = input('(M)asternode or (D)elegate: ').upper() while True: sk = getpass('Signing Key in Hex Format: ') try: wallet = Wallet(seed=bytes.fromhex(sk)) break except: print('Invalid format! Try again.') join_or_start = '' while join_or_start not in ['J', 'S']: join_or_start = input('(J)oin or (S)tart: ').upper() bootnodes = [] mn_seed = None if join_or_start == 'S': bootnode = '' while len(bootnodes) < 1 or bootnode != '': bootnode = input( 'Enter bootnodes as IP string. Press Enter twice to continue: ' ) if is_valid_ip(bootnode): print(f'Added {bootnode}.') bootnodes.append(bootnode) elif bootnode != '': print(f'Invalid IP string: {bootnode}') else: while mn_seed is None: mn_ip = input('Enter masternode as IP string: ') if is_valid_ip(mn_ip): mn_seed = mn_ip else: print(f'Invalid IP string: {mn_seed}') ip_str = requests.get('http://api.ipify.org').text socket_base = f'tcp://{ip_str}' mn_seed_str = f'tcp://{mn_seed}' const_url = input('URL of constitution: ') c = requests.get(const_url) const = resolve_raw_constitution(c.text) # start_rocks() if node_type == 'M': # Start mongo start_mongo() n = Masternode(wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, bootnodes=bootnodes, constitution=const, webserver_port=18080, mn_seed=mn_seed_str) elif node_type == 'D': n = Delegate(wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, bootnodes=bootnodes, constitution=const, mn_seed=mn_seed_str) loop = asyncio.get_event_loop() asyncio. async (n.start()) loop.run_forever()
def start_node(args): # sleep for restart module for ppid to be killed time.sleep(5) assert args.node_type == 'masternode' or args.node_type == 'delegate', \ 'Provide node type as "masternode" or "delegate"' sk = bytes.fromhex(args.key) wallet = Wallet(seed=sk) bootnodes = [] for node in args.boot_nodes: assert is_valid_ip( node), 'Invalid IP string provided to boot node argument.' bootnodes.append(f'tcp://{node}') assert len(bootnodes) > 0, 'Must provide at least one bootnode.' const = resolve_constitution(args.constitution) ip_str = requests.get('http://api.ipify.org').text socket_base = f'tcp://{ip_str}' # Setup Environment copyfile('/root/cilantro-enterprise/scripts/cil.service', '/etc/systemd/system/cil.service') # Enable Auto Restart # key, config = read_cfg() #use restart logic to start the node again # if key is None or config is None: # # booting for 1st time # enable = ask(question='Authorize auto restart for cilantro') # # if enable: # validate_key(restart=enable, key = args.key) # else: # print("Auto Restart is disabled manual intervention to restart CIL") if args.node_type == 'masternode': # Start mongo start_mongo() n = Masternode( wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, bootnodes=bootnodes, constitution=const, webserver_port=args.webserver_port, ) elif args.node_type == 'delegate': n = Delegate( wallet=wallet, ctx=zmq.asyncio.Context(), socket_base=socket_base, bootnodes=bootnodes, constitution=const, ) loop = asyncio.get_event_loop() asyncio. async (n.start()) loop.run_forever()
def test_init(self): b = Delegate(socket_base='tcp://127.0.0.1', wallet=Wallet(), ctx=self.ctx, bootnodes=bootnodes, constitution=constitution)