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 __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 __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 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 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 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, 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 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_invalid_signature(self): signing_key = SigObj.generate_signing_key() pub_key = signing.generate_pubkey(signing_key) temp = SignedObject({"PublicKey": pub_key}) invalid_signing_key = SigObj.generate_signing_key() # test invalid signature temp.sign_object(invalid_signing_key) self.assertFalse(temp.is_valid("invalid"))
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 test_create_quote_diff_submitted(self): key = signed_object.generate_signing_key() transaction = BondTransaction({ "UpdateType": "CreateQuote", 'Updates': [{ "UpdateType": "CreateQuote", "Firm": "ABCD", "Isin": "US912828R770", "BidPrice": "98-05.875", "BidQty": 25000, "AskPrice": "98-06.875", "AskQty": 25000 }] }) transaction.sign_object(key) try: transaction.check_valid(self.store) self.fail("Signed by an unauthorized participant") except InvalidTransactionError: pass transaction = BondTransaction({ "UpdateType": "CreateOrganization", 'Updates': [{"UpdateType": "CreateOrganization", "name": "NewBank", "ticker": "F", "pricing_source": "EFGH", "industry": "Test", "authorization": [] }] }) transaction.sign_object(self.key) transaction.check_valid(self.store) transaction.apply(self.store) key = signed_object.generate_signing_key() transaction = BondTransaction({ "UpdateType": "CreateQuote", 'Updates': [{ "UpdateType": "CreateQuote", "Firm": "EFGH", "Isin": "US912828R770", "BidPrice": "98-05.875", "BidQty": 25000, "AskPrice": "98-06.875", "AskQty": 25000 }] }) transaction.sign_object(self.key) try: transaction.check_valid(self.store) self.fail("Signed by an unauthorized participant") except InvalidTransactionError: pass
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.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 __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 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_xo_transaction_is_valid_invalid_space(self): key = signed_object.generate_signing_key() store = global_store_manager.KeyValueStore() # Create the game transaction = XoTransaction({ 'Action': 'CREATE', 'Name': 'game000' }) transaction.sign_object(key) self.assertTrue(transaction.is_valid(store)) transaction.apply(store) self.assertIn('game000', store) self.assertIn('Board', store['game000']) self.assertIn('State', store['game000']) self.assertEquals(store['game000']['State'], 'P1-NEXT') self.assertEquals(store['game000']['Board'], '---------') for space in [0, 10]: transaction = XoTransaction({ 'Action': 'TAKE', 'Name': 'game000', 'Space': space }) transaction.sign_object(key) self.assertFalse(transaction.is_valid(store))
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 _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_libor_update_date_in_the_future(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2100-01-01', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='G/gl8XhptfXUGih7X4g4s8EeXNXpX+qz7yEHd6ah1xXyrica2p' 'pdePFikWb9wbR5rOnvKC8FDAIg8CadhAaizt0=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_invalid_value_three_month(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 'invalid rate', 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='HO+xNW91CfhWVrvBKyk2P0rak82TPG8ZSsBucI3QhSXT7SegQd' 'y/Sq0dTZC+31rGQgMVdylbXLSO++aIb9OP0y8=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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_libor_update_invalid_value_two_month(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 'invalid rate', 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='HCi5tDerqxHZ8han4SmTqMsbKN1JscETRCqYDU3gNQSofp' 't8fm25i5xyo7EwBXDlxpcOyU5em8DVQOGsdyx8jXk=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_missing_date(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date=None, rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature="G78QicusrNO9l8Yxt/qJGX0TxkVh0ftSiW9dYkQPL5qYctd" "pb4Cq3GR15gT6DeHj0ujFcf4CK+Pu0Sqe77Zi92Y=") transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_invalid_value_one_month(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 'invalid rate', 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='G+eKJzXQBJCEgIj3ZZ46mfp73WqECskUBh4JPjFIMy9D2EAW0' '2ry7VN1NA6r4ZPf2dGtRY50yHSLrRwf/3Yn0gs=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_invalid_value_one_week(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 'invalid rate', 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='HBYQ8UxaSl6tTv2Ab3Hctki7kl+G8qBthr+4vVXRvJhMrppcEA3' 'CMtm3OitDoYsqmB6MC0WiFqqgSzOEiqJmPUg=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_invalid_value_overnight(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 'invalid rate', 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='HLwpLLCM0TdAOdyj/zpR4LUNp7QQosVTBBTqEq71zZkjKZ3a5y' 'SqRqFAC8Wgv9VQHyRbScLXJxFOG7xH83SxLYc=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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 test_libor_update_invalid_value_six_month(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 'invalid rate', 'OneYear': 0.1 }, signature='HHlwEyzhFYP53vg2tE44snVyAD4UUIzElBiaiNUPZLKrkGmO' '5TLHHmRJ8RvTAkxL5elIicRiNwOKc7JI0Zjkn5o=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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 test_libor_update_invalid_value_one_year(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 'invalid rate' }, signature='HDRqSWSJN8wCPMGITZLx0pW/ccqsMDYnnG9mbRUL3x1O8bz' 'tfGmgkD9n+6OQgb/glO52zuJdFIFV5ehCdr4L0Ug=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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_xo_transaction_is_valid_no_game(self): key = signed_object.generate_signing_key() store = global_store_manager.KeyValueStore() transaction = XoTransaction({"Action": "TAKE", "Name": "game000", "Space": 1}) transaction.sign_object(key) self.assertFalse(transaction.is_valid(store))
def test_libor_update_duplicate_date(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 0.1 }, signature='G38pbExUmKqKzdC07QJS1OJSglnpLKGr+PMu4muigey37CdT2P' '7d0PBQxmaWNjtsADdPxQAS5FhtHOQbtD41fkU=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) except InvalidTransactionError: self.fail('This transaction should be valid') transaction.apply(store) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_libor_update_signature_does_not_match(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': '0.1', 'OneWeek': '0.1', 'OneMonth': '0.1', 'TwoMonth': '0.1', 'ThreeMonth': '0.1', 'SixMonth': '0.1', 'OneYear': '0.1', }, signature='hjoq7knkzlxo4qubsjslfarl1ej/qso0ar4zsucd5xguniuvqjv' 'zj5lrqhayi5tqvniqxai0lkt31zqsztgojxw=') transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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 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 test_create_bond_creator(self): key = signed_object.generate_signing_key() transaction = BondTransaction({ "UpdateType": "CreateBond", 'Updates': [{ "UpdateType": "CreateBond", "amount_outstanding": 42671000000, 'corporate_debt_ratings': { "Fitch": "AAA", "Moodys": "AAA", "S&P": "AA+" }, "coupon_rate": 1.375, "coupon_type": "Fixed", "coupon_frequency": "Quarterly", "cusip": "912828R77", "face_value": 1000, "isin": "US912828R770", "first_settlement_date": "01/11/2012", "first_coupon_date": "03/01/2012", "maturity_date": "01/11/2022", "issuer": "T" }] }) transaction.sign_object(key) try: transaction.check_valid(self.store) self.fail("Bad creator") except InvalidTransactionError: pass
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 _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 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 test_libor_update_not_signed(self): key = signed_object.generate_signing_key() store = ObjectStore() update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': '0.1', 'OneWeek': '0.1', 'OneMonth': '0.1', 'TwoMonth': '0.1', 'ThreeMonth': '0.1', 'SixMonth': '0.1', 'OneYear': '0.1' }, signature=None) transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
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_libor_update_invalid_value_one_year(self): key = signed_object.generate_signing_key() store = ObjectStore() libor_key = TestCreateLIBORUpdate.libor_key libor_public_key = signing.generate_pubkey(libor_key) update = \ CreateLIBORUpdate( update_type='CreateLIBOR', date='2016-05-24', rates={ 'Overnight': 0.1, 'OneWeek': 0.1, 'OneMonth': 0.1, 'TwoMonth': 0.1, 'ThreeMonth': 0.1, 'SixMonth': 0.1, 'OneYear': 'invalid rate' }, libor_public_key=libor_public_key) update.sign_update_object(libor_key) transaction = BondTransaction() transaction._updates = [update] transaction.sign_object(key) try: transaction.check_valid(store) self.fail('This transaction should be invalid') except InvalidTransactionError: pass
def test_xo_transaction_is_valid_missing_action(self): key = signed_object.generate_signing_key() store = global_store_manager.KeyValueStore() transaction = XoTransaction({"Name": "game000"}) transaction.sign_object(key) self.assertFalse(transaction.is_valid(store))
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_xo_transaction_is_valid_create_same_name(self): key = signed_object.generate_signing_key() store = global_store_manager.KeyValueStore() store.set("game000", "{}") transaction = XoTransaction({"Action": "CREATE", "Name": "game000"}) transaction.sign_object(key) self.assertFalse(transaction.is_valid(store))
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_init(self): # Trival test creates a SignedObject # check that everything initalizes as expected signkey = SigObj.generate_signing_key() temp = SignedObject({signkey: "test"}, signkey) self.assertEquals(temp.SignatureKey, signkey) self.assertEquals(temp.dump(), {signkey: "test", "public_key": None}) self.assertEquals(temp.__repr__(), temp.serialize()) self.assertIsNotNone(temp.Identifier) temp._identifier = None self.assertIsNotNone(temp.Identifier)
def test_serialize(self): # Test that serilazation returns the correct dictionary and that # it can be retrieved. # create SignedObject signkey = SigObj.generate_signing_key() temp = SignedObject({signkey: "test"}, signkey) # serlize SignedObject cbor = temp.serialize() # check that the unserilized serilized dictinary is the same # as before serilazation self.assertEquals(cbor2dict(cbor), temp.dump())
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_xo_transaction_is_valid_invalid_action(self): key = signed_object.generate_signing_key() store = global_store_manager.KeyValueStore() transaction = XoTransaction({ 'Action': 'INVALID', 'Name': 'game000' }) transaction.sign_object(key) self.assertFalse(transaction.is_valid(store))
def __init__(self, base_url, store_name, name='SawtoothClient', transaction_type=None, message_type=None, keystring=None, keyfile=None): self._transaction_type = transaction_type self._message_type = message_type self._base_url = base_url self._communication = _Communication(base_url) self._last_transaction = None self._local_node = None state_communication = self._communication if base_url else None self._current_state = _ClientState( communication=state_communication, store_name=store_name, state_type=transaction_type.TransactionStoreType if transaction_type else global_store_manager.KeyValueStore) self._update_batch = None 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)