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)
