def test_journal_transaction_block_missing_transactions(self): # Test missing transactions, should return list of missing transactions minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10002)) path = tempfile.mkdtemp() # Takes a journal, create a temporary directory to use with the journal journal = Journal(node, DataDirectory=path) transBlock.sign_from_node(node) missing = transBlock.missing_transactions(journal) # No missing transactions self.assertEquals(missing, []) minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(), 'Dependencies': []} transaction = Transaction(minfo) transaction.sign_from_node(node) transBlock.TransactionIDs += [transaction.Identifier] missing = transBlock.missing_transactions(journal) # One missing transactions self.assertEquals(missing, [transaction.Identifier]) journal.TransactionStore[transaction.Identifier] = transaction missing = transBlock.missing_transactions(journal) # Back to no missing transactions self.assertEquals(missing, [])
def _setup(self, port): signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) firstNode = Node(identifier=ident, signingkey=signingkey, address=("localhost", port)) core = Gossip(firstNode) return core
def test_journal_transaction_block_update_block_weight(self): # Test block update weight minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) transBlock.Status = tbStatus.valid signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10003)) # Takes a journal, create a temporary directory to use with the journal path = tempfile.mkdtemp() journal = Journal(node, DataDirectory=path) transBlock.sign_from_node(node) transBlock.update_block_weight(journal) # No transactions self.assertEquals(transBlock.TransactionDepth, 0) minfo = {'__SIGNATURE__': 'Test', '__NONCE__': time.time(), 'Dependencies': []} transaction = Transaction(minfo) transaction.sign_from_node(node) transBlock.TransactionIDs += [transaction.Identifier] transBlock.update_block_weight(journal) # One transaction self.assertEquals(transBlock.TransactionDepth, 1) minfo = {'__SIGNATURE__': 'Test', "BlockNum": 1, 'PreviousBlockID': transBlock.Identifier} newTransBlock = TransactionBlock(minfo) newTransBlock.Status = tbStatus.valid journal.BlockStore[transBlock.Identifier] = transBlock newTransBlock.update_block_weight(journal) # Get depth from previous block self.assertEquals(newTransBlock.TransactionDepth, 1)
def _setup(self, port): signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) firstNode = Node(identifier=ident, signingkey=signingkey, address=("localhost", port)) core = Gossip(firstNode) return core
def __init__(self, baseurl, name='IntegerKeyClient', keystring=None, keyfile=None, state=None): super(IntegerKeyClient, self).__init__(baseurl) self.LastTransaction = None self.CurrentState = state or IntegerKeyState(self.BaseURL) self.CurrentState.fetch() # set up the signing key if keystring: logger.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: logger.debug("set signing key from file %s", keyfile) signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read().strip()) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self.LocalNode = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def test_register_validator_key_mismatch(self): key = signed_object.generate_signing_key() public_key_hash = \ hashlib.sha256( signing.encode_pubkey( signing.generate_pubkey(key), 'hex').encode()).hexdigest() key2 = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = \ SignupInfo.create_signup_info( validator_address='1660 Pennsylvania Avenue NW', originator_public_key_hash=public_key_hash, most_recent_wait_certificate_id='0' * 16) store = ObjectStore() transaction = \ ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key2) with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) self.fail("Failure: Verified an invalid transaction")
def _create_node(self): signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) node.is_peer = True return node
def test_register_validator_re_register(self): key = signed_object.generate_signing_key() public_key_hash = \ hashlib.sha256( signing.encode_pubkey( signing.generate_pubkey(key), 'hex').encode()).hexdigest() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = \ SignupInfo.create_signup_info( validator_address='1660 Pennsylvania Avenue NW', originator_public_key_hash=public_key_hash, most_recent_wait_certificate_id='0' * 16) store = ObjectStore() transaction = \ ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key) try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError as e: self.fail('Failed valid transaction: {}'.format(e)) try: # check if valid to register again transaction.check_valid(store) except InvalidTransactionError as e: self.fail('Failure: Double registered validator: {}'.format(e))
def _create_node(self, port): signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", port)) return node
def test_register_permissioned_validator_invalid(self): signing_key = signed_object.generate_signing_key() unpermissiond_private_key = signed_object.generate_signing_key() pub_key = pybitcointools.encode_pubkey( pybitcointools.privtopub(unpermissiond_private_key), 'hex') permissioned_public_keys = [pub_key] addr = signed_object.generate_identifier(unpermissiond_private_key) permissioned_addrs = [addr] update = { 'whitelist_name': "hyperledger.sawtooth-core.genesis-whitelist", 'verb': 'reg', 'permissioned_public_keys': permissioned_public_keys, 'permissioned_addrs': permissioned_addrs } minfo = {'Update': update} transaction = PermissionedValidatorRegistryTransaction(minfo) transaction.sign_object(signing_key) store = ObjectStore() with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) self.fail("Failure: Verified an invalid transaction")
def __init__(self, baseurl, creator=None, name='txnclient', keystring=None, keyfile=None, state=None, tokenstore=None): super(MarketPlaceClient, self).__init__(baseurl) self.CreatorID = creator self.LastTransaction = None self.CurrentState = state or MarketPlaceState(self.BaseURL) self.TokenStore = tokenstore # set up the signing key if keystring: logger.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: logger.debug("set signing key from file %s", keyfile) signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read()) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self.LocalNode = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def __init__(self, base_url, store_name, name='SawtoothClient', keystring=None, keyfile=None, state=None): self._communication = _Communication(base_url) self._base_url = base_url self._last_transaction = None self._local_node = None self._current_state = state or _ClientState(base_url, store_name) self.fetch_state() # Set up the signing key. Note that if both the keystring and # keyfile are not provided, then this is in essence a "read-only" # client that may not issue transactions. signingkey = None if keystring: LOGGER.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: LOGGER.debug("set signing key from file %s", keyfile) try: signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read().strip()) except IOError as ex: raise ClientException( "Failed to load key file: {}".format(str(ex))) if signingkey: identifier = signed_object.generate_identifier(signingkey) self._local_node = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def initialize_ledger_object(self): # Create the local ledger instance name = self.Config['NodeName'] addr = \ (socket.gethostbyname(self._gossip_host), self._gossip_port) endpoint_addr = (self._endpoint_host, self._endpoint_port) signingkey = signed_object.generate_signing_key( wifstr=self.Config.get('SigningKey')) identifier = signed_object.generate_identifier(signingkey) nd = node.Node(address=addr, identifier=identifier, signingkey=signingkey, name=name, endpoint_address=endpoint_addr) self.initialize_ledger_from_node(nd) assert self.Ledger for txnfamily in self.DefaultTransactionFamilies: txnfamily.register_transaction_types(self.Ledger) self.Ledger.onNodeDisconnect += self.handle_node_disconnect_event logger.info("starting ledger %s with id %s at network address %s", self.Ledger.LocalNode, self.Ledger.LocalNode.Identifier[:8], self.Ledger.LocalNode.NetAddress)
def _create_node(self): signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) node.is_peer = True return node
def test_register_permissioned_validator_invalid(self): signing_key = signed_object.generate_signing_key() unpermissiond_private_key = signed_object.generate_signing_key() pub_key = pybitcointools.encode_pubkey( pybitcointools.privtopub(unpermissiond_private_key), 'hex') permissioned_public_keys = [pub_key] addr = signed_object.generate_identifier(unpermissiond_private_key) permissioned_addrs = [addr] update = { 'whitelist_name': "hyperledger.sawtooth-core.genesis-whitelist", 'verb': 'reg', 'permissioned_public_keys': permissioned_public_keys, 'permissioned_addrs': permissioned_addrs } minfo = {'Update': update} transaction = PermissionedValidatorRegistryTransaction(minfo) transaction.sign_object(signing_key) store = ObjectStore() with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) self.fail("Failure: Verified an invalid transaction")
def _create_node(self): signingkey = signed_object.generate_signing_key() ident = signed_object.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", self._next_port)) self.__class__._next_port = self._next_port + 1 return node
def __init__(self, baseurl, name='IntegerKeyClient', keystring=None, keyfile=None, state=None): super(IntegerKeyClient, self).__init__(baseurl) self.LastTransaction = None self.CurrentState = state or IntegerKeyState(self.BaseURL) self.CurrentState.fetch() # set up the signing key if keystring: logger.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: logger.debug("set signing key from file %s", keyfile) signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read()) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self.LocalNode = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def initialize_ledger_object(self): # Create the local ledger instance name = self.Config['NodeName'] if name in self.NodeMap: nd = self.NodeMap[name] else: host = self.Config['Host'] port = self.Config['Port'] addr = (socket.gethostbyname(host), port) signingkey = signed_object.generate_signing_key( wifstr=self.Config.get('SigningKey')) identifier = signed_object.generate_identifier(signingkey) nd = node.Node(address=addr, identifier=identifier, signingkey=signingkey, name=name) self.initialize_ledger_from_node(nd) assert self.Ledger for txnfamily in self.DefaultTransactionFamilies: txnfamily.register_transaction_types(self.Ledger) self.Ledger.onNodeDisconnect += self.handle_node_disconnect_event logger.info("starting ledger %s with id %s at network address %s", self.Ledger.LocalNode, self.Ledger.LocalNode.Identifier[:8], self.Ledger.LocalNode.NetAddress)
def test_journal_transaction_block_missing_transactions(self): # Test missing transactions, should return list of missing transactions minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10002)) path = tempfile.mkdtemp() # Takes a journal, create a temporary directory to use with the journal journal = Journal(node, DataDirectory=path) transBlock.sign_from_node(node) missing = transBlock.missing_transactions(journal) # No missing transactions self.assertEquals(missing, []) minfo = { '__SIGNATURE__': 'Test', '__NONCE__': time.time(), 'Dependencies': [] } transaction = Transaction(minfo) transaction.sign_from_node(node) transBlock.TransactionIDs += [transaction.Identifier] missing = transBlock.missing_transactions(journal) # One missing transactions self.assertEquals(missing, [transaction.Identifier]) journal.TransactionStore[transaction.Identifier] = transaction missing = transBlock.missing_transactions(journal) # Back to no missing transactions self.assertEquals(missing, [])
def __init__(self, baseurl, creator=None, name='txnclient', keystring=None, keyfile=None, state=None, tokenstore=None): super(MarketPlaceClient, self).__init__(baseurl) self.CreatorID = creator self.LastTransaction = None self.CurrentState = state or MarketPlaceState(self.BaseURL) self.TokenStore = tokenstore # set up the signing key if keystring: logger.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: logger.debug("set signing key from file %s", keyfile) signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read()) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self.LocalNode = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def test_register_validator_key_mismatch(self): key = signed_object.generate_signing_key() public_key_hash = \ hashlib.sha256( signing.encode_pubkey( signing.generate_pubkey(key), 'hex')).hexdigest() key2 = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = \ SignupInfo.create_signup_info( originator_public_key_hash=public_key_hash, most_recent_wait_certificate_id='0' * 16) store = ObjectStore() transaction = \ ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key2) with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) self.fail("Failure: Verified an invalid transaction")
def _create_node(self): signingkey = signed_object.generate_signing_key() ident = signed_object.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", self._next_port)) self.__class__._next_port = self._next_port + 1 return node
def test_register_validator_re_register(self): key = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = \ SignupInfo.create_signup_info( originator_public_key=pybitcointools.privtopub(key), validator_network_basename='Intel Validator Network', most_recent_wait_certificate_id='0' * 16) store = KeyValueStore() transaction = \ ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key) try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError as e: self.fail('Failed valid transaction: {}'.format(e)) try: # check if valid to register again transaction.check_valid(store) except InvalidTransactionError as e: self.fail('Failure: Double registered validator: {}'.format(e))
def test_register_validator_re_register(self): key = signed_object.generate_signing_key() public_key_hash = \ hashlib.sha256( signing.encode_pubkey( signing.generate_pubkey(key), 'hex')).hexdigest() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = \ SignupInfo.create_signup_info( originator_public_key_hash=public_key_hash, most_recent_wait_certificate_id='0' * 16) store = ObjectStore() transaction = \ ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key) try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError as e: self.fail('Failed valid transaction: {}'.format(e)) try: # check if valid to register again transaction.check_valid(store) except InvalidTransactionError as e: self.fail('Failure: Double registered validator: {}'.format(e))
def __init__(self, base_url, store_name, name='SawtoothClient', keystring=None, keyfile=None, state=None): super(SawtoothClient, self).__init__(base_url) self._last_transaction = None self._current_state = state or ClientState(base_url, store_name) self._current_state.fetch() # set up the signing key if keystring: LOGGER.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: LOGGER.debug("set signing key from file %s", keyfile) try: signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read().strip()) except IOError as ex: raise ClientException( "Failed to load key file: {}".format(str(ex))) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self._local_node = node.Node(identifier=identifier, signingkey=signingkey, name=name)
def test_generate_coupons_coupon(self): self._set_clock(2015, 4, 1, 1) signingkey = signed_object.generate_signing_key() ident = signed_object.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10021)) node.is_peer = True path = tempfile.mkdtemp() gossip = Gossip(node) journal = Journal(node, gossip, gossip.dispatcher, consensus=DevModeConsensus(), data_directory=path) journal.global_store.TransactionStores['/BondTransaction'] = \ self.store # creates a redemption updates = Family._generate_coupons(journal) self.assertNotEquals(updates, []) transaction = BondTransaction(updates[0]) transaction.sign_object(self.key) transaction.check_valid(self.store) transaction.apply(self.store) org_usd_holding = self.store["34d813716009ca1786222a44347ccff" "258a4ab6029d936664fde0d13f23992b5"] self.assertEquals(org_usd_holding["amount"], 25000.0)
def do_set(self, args): """ set -- Command to set properties of the interpreter set url --url <url> set nodeid --name <name> --keyfile <file> """ pargs = args.split() if len(pargs) == 0: print 'missing subcommand url|nodeid' return try: if pargs[0] == 'url': parser = argparse.ArgumentParser() parser.add_argument('--url', help='url used to connect to a validator', required=True) options = parser.parse_args(pargs) self.BaseURL = options.url print "server URL set to {0}".format(self.BaseURL) return elif pargs[0] == 'nodeid': pargs = args.split() parser = argparse.ArgumentParser() parser.add_argument('--name', help='name to use for the client', default='txnclient') parser.add_argument('--keyfile', help='name of the file that contains ' 'the wif format private key') options = parser.parse_args(pargs[1:]) addr = (socket.gethostbyname("localhost"), 0) name = options.name if options.keyfile: signingkey = generate_signing_key( wifstr=read_key_file(options.keyfile)) else: signingkey = generate_signing_key() identifier = generate_identifier(signingkey) self.LocalNode = Node(address=addr, identifier=identifier, signingkey=signingkey, name=name) print "local id set to {0}".format(self.LocalNode) return else: print "unknown subcommand; {0}".format(pargs[0]) return except Exception as e: print 'an error occured processing {0}: {1}'.format(args, str(e)) return
def do_set(self, args): """ set -- Command to set properties of the interpreter set url --url <url> set nodeid --name <name> --keyfile <file> """ pargs = args.split() if len(pargs) == 0: print 'missing subcommand url|nodeid' return try: if pargs[0] == 'url': parser = argparse.ArgumentParser() parser.add_argument('--url', help='url used to connect to a validator', required=True) options = parser.parse_args(pargs) self.BaseURL = options.url print "server URL set to {0}".format(self.BaseURL) return elif pargs[0] == 'nodeid': pargs = args.split() parser = argparse.ArgumentParser() parser.add_argument('--name', help='name to use for the client', default='txnclient') parser.add_argument('--keyfile', help='name of the file that contains ' 'the wif format private key') options = parser.parse_args(pargs[1:]) addr = (socket.gethostbyname("localhost"), 0) name = options.name if options.keyfile: signingkey = generate_signing_key( wifstr=read_key_file(options.keyfile)) else: signingkey = generate_signing_key() identifier = generate_identifier(signingkey) self.LocalNode = Node(address=addr, identifier=identifier, signingkey=signingkey, name=name) print "local id set to {0}".format(self.LocalNode) return else: print "unknown subcommand; {0}".format(pargs[0]) return except Exception as e: print 'an error occured processing {0}: {1}'.format(args, str(e)) return
def test_gossip_core_init(self): # Test correct init signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) firstNode = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) core = Gossip(firstNode) self.assertIsNotNone(core)
def test_gossip_core_init(self): # Test correct init signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) firstNode = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) core = Gossip(firstNode) self.assertIsNotNone(core)
def _create_node(self, port=None): if port is None: port = self._next_port self.__class__._next_port = self._next_port + 1 signingkey = sign_obj.generate_signing_key() ident = sign_obj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", port)) return node
def __init__(self, base_url, store_name=None, name='SawtoothClient', transaction_type=None, message_type=None, keystring=None, keyfile=None, disable_client_validation=False): self._base_url = base_url self._message_type = message_type self._transaction_type = transaction_type # An explicit store name takes precedence over a store name # implied by the transaction type. self._store_name = None if store_name is not None: self._store_name = store_name.strip('/') elif transaction_type is not None: self._store_name = transaction_type.TransactionTypeName.strip('/') self._communication = _Communication(base_url) self._last_transaction = None self._local_node = None self._update_batch = None self._disable_client_validation = disable_client_validation # We only keep current state if we have a store name self._current_state = None if self._store_name is not None: state_type = global_store_manager.KeyValueStore if transaction_type is not None: state_type = transaction_type.TransactionStoreType self._current_state = \ _ClientState(client=self, state_type=state_type) self.fetch_state() signing_key = None if keystring: LOGGER.debug("set signing key from string\n%s", keystring) signing_key = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: LOGGER.debug("set signing key from file %s", keyfile) try: signing_key = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read().strip()) except IOError as ex: raise ClientException("Failed to load key file: {}".format( str(ex))) if signing_key: identifier = signed_object.generate_identifier(signing_key) self._local_node = node.Node(identifier=identifier, signingkey=signing_key, name=name)
def __init__(self, base_url, store_name=None, name='SawtoothClient', transaction_type=None, message_type=None, keystring=None, keyfile=None, disable_client_validation=False): self._base_url = base_url self._message_type = message_type self._transaction_type = transaction_type # An explicit store name takes precedence over a store name # implied by the transaction type. self._store_name = None if store_name is not None: self._store_name = store_name.strip('/') elif transaction_type is not None: self._store_name = transaction_type.TransactionTypeName.strip('/') self._communication = _Communication(base_url) self._last_transaction = None self._local_node = None self._update_batch = None self._disable_client_validation = disable_client_validation # We only keep current state if we have a store name self._current_state = None if self._store_name is not None: state_type = global_store_manager.KeyValueStore if transaction_type is not None: state_type = transaction_type.TransactionStoreType self._current_state = \ _ClientState(client=self, state_type=state_type) self.fetch_state() signing_key = None if keystring: LOGGER.debug("set signing key from string\n%s", keystring) signing_key = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: LOGGER.debug("set signing key from file %s", keyfile) try: signing_key = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read().strip()) except IOError as ex: raise ClientException( "Failed to load key file: {}".format(str(ex))) if signing_key: identifier = signed_object.generate_identifier(signing_key) self._local_node = node.Node(identifier=identifier, signingkey=signing_key, name=name)
def _create_node(self, port=None): if port is None: port = self._next_port self.__class__._next_port = self._next_port + 1 signingkey = sign_obj.generate_signing_key() ident = sign_obj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", port)) return node
def test_gossip_core_bad_node_address(self): # Make sure it fails if given a node without an address # Should always throw an error signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey) try: core = Gossip(node) self.fail("Should raise an error") except GossipException, e: self.assertIsInstance(e, GossipException)
def test_gossip_core_bad_node_address(self): # Make sure it fails if given a node without an address # Should always throw an error signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey) try: core = Gossip(node) self.fail("Should raise an error") except GossipException, e: self.assertIsInstance(e, GossipException)
def __init__(self, baseurl, keystring=None): cmd.Cmd.__init__(self) self.prompt = 'client> ' self._current_state = {} self._client = SawtoothClient(baseurl) signingkey = generate_signing_key( wifstr=keystring) if keystring else generate_signing_key() identifier = generate_identifier(signingkey) self._local_node = Node(identifier=identifier, signingkey=signingkey, name="txnclient")
def __init__(self, baseurl, keystring=None): cmd.Cmd.__init__(self) self.prompt = 'client> ' self.CurrentState = {} self.LedgerWebClient = ledger_web_client.LedgerWebClient(baseurl) signingkey = generate_signing_key( wifstr=keystring) if keystring else generate_signing_key() identifier = generate_identifier(signingkey) self.LocalNode = Node(identifier=identifier, signingkey=signingkey, name="txnclient")
def __init__(self, baseurl, keystring=None): cmd.Cmd.__init__(self) self.prompt = 'client> ' self._current_state = {} self._client = SawtoothClient(baseurl) signingkey = generate_signing_key( wifstr=keystring) if keystring else generate_signing_key() identifier = generate_identifier(signingkey) self._local_node = Node(identifier=identifier, signingkey=signingkey, name="txnclient")
def __init__(self, baseurl, keystring=None): cmd.Cmd.__init__(self) self.prompt = 'client> ' self.CurrentState = {} self.LedgerWebClient = LedgerWebClient(baseurl) signingkey = generate_signing_key( wifstr=keystring) if keystring else generate_signing_key() identifier = generate_identifier(signingkey) self.LocalNode = Node(identifier=identifier, signingkey=signingkey, name="txnclient")
def node_from_config(config): name = config['NodeName'] signing_key = generate_signing_key(wifstr=read_key_file(config['KeyFile'])) (gossip_host, gossip_port) = parse_listen_directives(config)['gossip'] # stubbing endpoint address for now endpoint_addr = (None, None) nd = node.Node(address=(socket.gethostbyname(gossip_host), gossip_port), identifier=generate_identifier(signing_key), signingkey=signing_key, name=name, endpoint_address=endpoint_addr, ) return nd
def test_register_permissioned_validator_valid(self): signing_key = signed_object.generate_signing_key() try: priv_key1 = pybitcointools.decode_privkey( open('./tests/unit/keys/pv1.wif', "r") .read().strip(), 'wif') priv_key2 = pybitcointools.decode_privkey( open('./tests/unit/keys/pv2.wif', "r") .read().strip(), 'wif') except IOError as ex: raise Exception('IOError: {}'.format(str(ex))) pub_key1 = pybitcointools.encode_pubkey( pybitcointools.privtopub(priv_key1), 'hex') pub_key2 = pybitcointools.encode_pubkey( pybitcointools.privtopub(priv_key2), 'hex') permissioned_public_keys = [pub_key1, pub_key2] addr1 = signed_object.generate_identifier(priv_key1) addr2 = signed_object.generate_identifier(priv_key2) permissioned_addrs = [addr1, addr2] update = { 'whitelist_name': "hyperledger.sawtooth-core.genesis-whitelist", 'verb': 'reg', 'permissioned_public_keys': permissioned_public_keys, 'permissioned_addrs': permissioned_addrs } minfo = {'Update': update} transaction = PermissionedValidatorRegistryTransaction(minfo) transaction.sign_object(signing_key) store = ObjectStore() try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError as e: self.fail('Failed valid transaction: {}'.format(e))
def test_journal_transaction_block_is_valid(self): # Test whether or not a transblock is valid minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10000)) # Takes a journal, create a temporary directory to use with the journal path = tempfile.mkdtemp() journal = Journal(node, DataDirectory=path) # Need to sign TransactionBlock, use sign_from_node form signed object transBlock.sign_from_node(node) self.assertTrue(transBlock.is_valid(journal))
def test_register_permissioned_validator_valid(self): signing_key = signed_object.generate_signing_key() try: priv_key1 = pybitcointools.decode_privkey( open('./tests/unit/keys/pv1.wif', "r").read().strip(), 'wif') priv_key2 = pybitcointools.decode_privkey( open('./tests/unit/keys/pv2.wif', "r").read().strip(), 'wif') except IOError as ex: raise Exception('IOError: {}'.format(str(ex))) pub_key1 = pybitcointools.encode_pubkey( pybitcointools.privtopub(priv_key1), 'hex') pub_key2 = pybitcointools.encode_pubkey( pybitcointools.privtopub(priv_key2), 'hex') permissioned_public_keys = [pub_key1, pub_key2] addr1 = signed_object.generate_identifier(priv_key1) addr2 = signed_object.generate_identifier(priv_key2) permissioned_addrs = [addr1, addr2] update = { 'whitelist_name': "hyperledger.sawtooth-core.genesis-whitelist", 'verb': 'reg', 'permissioned_public_keys': permissioned_public_keys, 'permissioned_addrs': permissioned_addrs } minfo = {'Update': update} transaction = PermissionedValidatorRegistryTransaction(minfo) transaction.sign_object(signing_key) store = ObjectStore() try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError as e: self.fail('Failed valid transaction: {}'.format(e))
def node_from_config(config): name = config['NodeName'] signing_key = generate_signing_key(wifstr=read_key_file(config['KeyFile'])) listen_info = config.get("Listen") (gossip_host, gossip_port) = parse_listen_directives(listen_info)['gossip'] # stubbing endpoint address for now endpoint_addr = (None, None) nd = node.Node( address=(socket.gethostbyname(gossip_host), gossip_port), identifier=generate_identifier(signing_key), signingkey=signing_key, name=name, endpoint_address=endpoint_addr, ) return nd
def test_journal_transaction_block_str(self): # Test str function for a signed transaction block minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) # Need to sign TransactionBlock, use sign_from_node form signed object transBlock.sign_from_node(node) self.assertEquals(str(transBlock), "{0}, {1}, {2}, {3:0.2f}" .format(transBlock.BlockNum, transBlock.Identifier[:8], len(transBlock.TransactionIDs), transBlock.CommitTime))
def test_journal_transaction_block_build_message(self): # Test build_message, returns a TransactionBlockMessage minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) transBlock.sign_from_node(node) transBlock.Status = tbStatus.valid msg = transBlock.build_message() self.assertEquals(msg.MessageType, "/journal.messages.TransactionBlockMessage" + "/TransactionBlock") self.assertEquals(msg.TransactionBlock, transBlock)
def test_journal_transaction_block_str(self): # Test str function for a signed transaction block minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) # Need to sign TransactionBlock, use sign_from_node form signed object transBlock.sign_from_node(node) self.assertEquals(str(transBlock), "{0}, {1}, {2}, {3:0.2f}" .format(transBlock.BlockNum, transBlock.Identifier[:8], len(transBlock.TransactionIDs), transBlock.CommitTime))
def test_node_init(self): # Test normal Init for a single node signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) self.assertEquals(node.NetHost, "localhost") self.assertEquals(node.NetPort, 8800) self.assertEquals(node.Identifier, ident) self.assertEquals(node.SigningKey, signingkey) self.assertEquals(node.Name, ident[:8]) self.assertFalse(node.is_peer) self.assertIsInstance(node.Estimator, RoundTripEstimator) self.assertIsInstance(node.MessageQ, TransmissionQueue) self.assertEquals(node.Delay, node._fixeddelay)
def test_journal_transaction_block_build_message(self): # Test build_message, returns a TransactionBlockMessage minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) transBlock.sign_from_node(node) transBlock.Status = tbStatus.valid msg = transBlock.build_message() self.assertEquals(msg.MessageType, "/journal.messages.TransactionBlockMessage" + "/TransactionBlock") self.assertEquals(msg.TransactionBlock, transBlock)
def test_journal_transaction_block_is_valid(self): # Test whether or not a transblock is valid minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10000)) # Takes a journal, create a temporary directory to use with the journal path = tempfile.mkdtemp() journal = Journal(node, DataDirectory=path) # Need to sign TransactionBlock, use sign_from_node form signed object transBlock.sign_from_node(node) self.assertTrue(transBlock.is_valid(journal))
def test_journal_transaction_block_dump(self): # Test that transactions dump the correct info minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) transBlock.sign_from_node(node) transBlock.Status = tbStatus.valid tbDic = transBlock.dump() self.assertEquals(tbDic["TransactionIDs"], []) self.assertEquals(tbDic["TransactionBlockType"], "/TransactionBlock") self.assertEquals(tbDic["BlockNum"], 0) self.assertIsNotNone(tbDic["Signature"]) self.assertNotEquals(tbDic["Signature"], "")
def test_journal_transaction_block_dump(self): # Test that transactions dump the correct info minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) transBlock.sign_from_node(node) transBlock.Status = tbStatus.valid tbDic = transBlock.dump() self.assertEquals(tbDic["TransactionIDs"], []) self.assertEquals(tbDic["TransactionBlockType"], "/TransactionBlock") self.assertEquals(tbDic["BlockNum"], 0) self.assertIsNotNone(tbDic["Signature"]) self.assertNotEquals(tbDic["Signature"], "")
def test_journal_transaction_block_not_is_valid(self): # Test that an invalid Transblock does not get verified as valid minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10001)) # Takes a journal, create a temporary directory to use with the journal path = tempfile.mkdtemp() journal = Journal(node, DataDirectory=path) # Need to sign TransactionBlock, use sign_from_node form signed object try: transBlock.is_valid(journal) except AssertionError, e: self.assertIsInstance(e, AssertionError)
def test_register_validator_valid(self): key = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = dict2json({'poet_public_key': 'fake_key', 'anti_sybil_id': 'some_token', 'proof_data': 'proof'}) store = KeyValueStore() transaction = ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key) try: transaction.check_valid(store) transaction.apply(store) except InvalidTransactionError: self.fail("Bad: Failed valid transaction")
def test_register_validator_key_mismatch(self): key = signed_object.generate_signing_key() key2 = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = dict2json({'poet_public_key': 'fake_key', 'anti_sybil_id': 'some_token', 'proof_data': 'proof'}) store = KeyValueStore() transaction = ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key2) with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) transaction.apply(store) self.fail("Failure: Verified an invalid transaction")
def test_node_init(self): # Test normal Init for a single node signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 8800)) self.assertEqual(node.NetHost, "localhost") self.assertEqual(node.NetPort, 8800) self.assertEqual(node.Identifier, ident) self.assertEqual(node.SigningKey, signingkey) self.assertEqual(node.Name, ident[:8]) self.assertFalse(node.is_peer) self.assertIsInstance(node.Estimator, RoundTripEstimator) self.assertIsInstance(node.MessageQ, TransmissionQueue) self.assertEqual(node.Delay, node._fixeddelay)
def test_register_validator_key_mismatch(self): key = signed_object.generate_signing_key() key2 = signed_object.generate_signing_key() validator_id = signed_object.generate_identifier(key) name = 'DasValidator' signup_info = dict2json({'poet_pubkey': 'fake_key', 'anti_sybil_id': 'some_token', 'proof_data': 'proof'}) store = KeyValueStore() transaction = ValidatorRegistryTransaction.register_validator( name, validator_id, signup_info) transaction.sign_object(key2) with self.assertRaises(InvalidTransactionError): transaction.check_valid(store) transaction.apply(store) self.fail("Failure: Verified an invalid transaction")
def test_journal_transaction_block_not_is_valid(self): # Test that an invalid Transblock does not get verified as valid minfo = {'__SIGNATURE__': 'Test', "BlockNum": 0} transBlock = TransactionBlock(minfo) signingkey = SigObj.generate_signing_key() ident = SigObj.generate_identifier(signingkey) node = Node(identifier=ident, signingkey=signingkey, address=("localhost", 10001)) # Takes a journal, create a temporary directory to use with the journal path = tempfile.mkdtemp() journal = Journal(node, DataDirectory=path) # Need to sign TransactionBlock, use sign_from_node form signed object try: transBlock.is_valid(journal) except AssertionError, e: self.assertIsInstance(e, AssertionError)