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,
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 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 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_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 __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 _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()
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)
