def migrate_genesis_txn(base_dir):
for suffix in ('sandbox', 'live', 'local'):
old_domain_genesis = os.path.join(
base_dir, 'transactions_{}'.format(suffix))
old_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}'.format(suffix))
new_domain_genesis = os.path.join(
base_dir, 'domain_transactions_{}_genesis'.format(suffix))
new_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}_genesis'.format(suffix))
if os.path.exists(old_domain_genesis):
os.remove(old_domain_genesis)
if os.path.exists(old_pool_genesis):
os.remove(old_pool_genesis)
if os.path.exists(new_domain_genesis):
old_ser = CompactSerializer(getTxnOrderedFields())
new_ser = JsonSerializer()
with open(new_domain_genesis, 'r') as f1:
with open(old_domain_genesis, 'w') as f2:
for line in store_utils.cleanLines(f1):
txn = new_ser.deserialize(line)
txn = old_ser.serialize(txn)
f2.write(txn)
os.remove(new_domain_genesis)
if os.path.exists(new_pool_genesis):
os.rename(new_pool_genesis, old_domain_genesis)
def migrate_genesis_txn(base_dir):
for suffix in ('sandbox', 'live', 'local'):
old_domain_genesis = os.path.join(
base_dir, 'transactions_{}'.format(suffix))
old_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}'.format(suffix))
new_domain_genesis = os.path.join(
base_dir, 'domain_transactions_{}_genesis'.format(suffix))
new_pool_genesis = os.path.join(
base_dir, 'pool_transactions_{}_genesis'.format(suffix))
if os.path.exists(old_domain_genesis):
os.remove(old_domain_genesis)
if os.path.exists(old_pool_genesis):
os.remove(old_pool_genesis)
if os.path.exists(new_domain_genesis):
old_ser = CompactSerializer(getTxnOrderedFields())
new_ser = JsonSerializer()
with open(new_domain_genesis, 'r') as f1:
with open(old_domain_genesis, 'w') as f2:
for line in store_utils.cleanLines(f1):
txn = new_ser.deserialize(line)
txn = old_ser.serialize(txn)
f2.write(txn)
os.remove(new_domain_genesis)
if os.path.exists(new_pool_genesis):
os.rename(new_pool_genesis, old_domain_genesis)
def test_genesis_txn_file_initiator(tempdir, init_genesis_txn_file, genesis_txns):
# Check that initiator of genesis txns work:
# It uses a text file with JsonSerializer by default
genesis_file = genesis_txn_file(
os.path.join(tempdir, init_genesis_txn_file))
assert os.path.exists(genesis_file)
i = 0
serializer = JsonSerializer()
with open(genesis_file) as f:
for line in store_utils.cleanLines(f.readlines()):
assert sorted(serializer.deserialize(line).items()
) == sorted(genesis_txns[i].items())
i += 1
def test_genesis_txn_file_initiator(tempdir, init_genesis_txn_file, genesis_txns):
# Check that initiator of genesis txns work:
# It uses a text file with JsonSerializer by default
genesis_file = genesis_txn_file(
os.path.join(tempdir, init_genesis_txn_file))
assert os.path.exists(genesis_file)
i = 0
serializer = JsonSerializer()
with open(genesis_file) as f:
for line in store_utils.cleanLines(f.readlines()):
assert sorted(serializer.deserialize(line).items()
) == sorted(genesis_txns[i].items())
i += 1
def testJsonSerializer():
sz = JsonSerializer()
m1 = {
'integer': 36,
'name': 'Foo',
'surname': 'Bar',
'float': 14.8639,
'index': 1,
'index_start_at': 56,
'email': '*****@*****.**',
'fullname': 'Foo Bar',
'bool': False
}
m1s = '{"bool":false,"email":"*****@*****.**","float":14.8639,"fullname":"Foo Bar",' \
'"index":1,"index_start_at":56,"integer":36,"name":"Foo","surname":"Bar"}'
m2 = {
'latitude': 31.351883,
'longitude': -97.466179,
'tags': ['foo', 'bar', 'baz', 'alice', 'bob', 'carol', 'dave']
}
m2s = '{"latitude":31.351883,"longitude":-97.466179,' \
'"tags":["foo","bar","baz","alice","bob","carol","dave"]}'
m3 = {
'name':
'Alice Bob',
'website':
'example.com',
'friends': [{
'id': 0,
'name': 'Dave'
}, {
'id': 1,
'name': 'Carol'
}, {
'id': 2,
'name': 'Dave'
}]
}
m3s = '{"friends":[{"id":0,"name":"Dave"},{"id":1,"name":"Carol"},' \
'{"id":2,"name":"Dave"}],' \
'"name":"Alice Bob","website":"example.com"}'
assert sz.serialize(m1) == m1s.encode()
assert sz.serialize(m1, toBytes=False) == m1s
assert sz.serialize(m2) == m2s.encode()
assert sz.serialize(m2, toBytes=False) == m2s
assert sz.serialize(m3) == m3s.encode()
assert sz.serialize(m3, toBytes=False) == m3s
assert sz.deserialize(m1s) == m1
assert sz.deserialize(m1s.encode()) == m1
assert sz.deserialize(m2s) == m2
assert sz.deserialize(m2s.encode()) == m2
assert sz.deserialize(m3s) == m3
assert sz.deserialize(m3s.encode()) == m3
def test_pool_genesis_txns(bootstrap, pool_genesis_file):
serializer = JsonSerializer()
with open(pool_genesis_file) as f:
for line in store_utils.cleanLines(f.readlines()):
txn = serializer.deserialize(line)
assert get_seq_no(txn)
assert get_txn_id(txn)
assert get_payload_data(txn)
assert get_type(txn) == NODE
assert get_version(txn) == "1"
assert get_payload_data(txn)[TARGET_NYM]
data = get_payload_data(txn).get(DATA)
assert data
assert data[ALIAS]
assert data[CLIENT_IP]
assert data[CLIENT_PORT]
assert data[NODE_IP]
assert data[NODE_PORT]
assert data[SERVICES] == [VALIDATOR]
assert data[BLS_KEY]
def test_pool_genesis_txns(bootstrap, pool_genesis_file):
serializer = JsonSerializer()
with open(pool_genesis_file) as f:
for line in store_utils.cleanLines(f.readlines()):
txn = serializer.deserialize(line)
assert get_seq_no(txn)
assert get_txn_id(txn)
assert get_payload_data(txn)
assert get_type(txn) == NODE
assert get_version(txn) == "1"
assert get_protocol_version(txn) is None
assert get_payload_data(txn)[TARGET_NYM]
data = get_payload_data(txn).get(DATA)
assert data
assert data[ALIAS]
assert data[CLIENT_IP]
assert data[CLIENT_PORT]
assert data[NODE_IP]
assert data[NODE_PORT]
assert data[SERVICES] == [VALIDATOR]
assert data[BLS_KEY]
assert data[BLS_KEY_PROOF]
def test_domain_genesis_txns(bootstrap, domain_genesis_file):
serializer = JsonSerializer()
with open(domain_genesis_file) as f:
i = 0
for line in store_utils.cleanLines(f.readlines()):
txn = serializer.deserialize(line)
assert get_seq_no(txn)
assert get_payload_data(txn)
assert get_type(txn) == NYM
assert get_version(txn) == "1"
assert get_payload_data(txn)[VERKEY]
assert get_payload_data(txn)[TARGET_NYM]
assert ALIAS not in get_payload_data(txn)
# expect Trustees, then Stewards, then Clients
if 0 <= i < TRUSTEE_COUNT:
expected_role = TRUSTEE
elif TRUSTEE_COUNT <= i < TRUSTEE_COUNT + NODE_COUNT:
expected_role = STEWARD
else:
expected_role = None
assert get_payload_data(txn).get(ROLE) == expected_role
i += 1
def testJsonSerializer():
sz = JsonSerializer()
m1 = {'integer': 36, 'name': 'Foo', 'surname': 'Bar', 'float': 14.8639,
'index': 1, 'index_start_at': 56, 'email': '*****@*****.**',
'fullname': 'Foo Bar', 'bool': False}
m1s = '{"bool":false,"email":"*****@*****.**","float":14.8639,"fullname":"Foo Bar",' \
'"index":1,"index_start_at":56,"integer":36,"name":"Foo","surname":"Bar"}'
m2 = {'latitude': 31.351883, 'longitude': -97.466179,
'tags': ['foo', 'bar', 'baz', 'alice', 'bob',
'carol', 'dave']}
m2s = '{"latitude":31.351883,"longitude":-97.466179,' \
'"tags":["foo","bar","baz","alice","bob","carol","dave"]}'
m3 = {'name': 'Alice Bob', 'website': 'example.com', 'friends': [
{
'id': 0,
'name': 'Dave'
},
{
'id': 1,
'name': 'Carol'
},
{
'id': 2,
'name': 'Dave'
}]}
m3s = '{"friends":[{"id":0,"name":"Dave"},{"id":1,"name":"Carol"},' \
'{"id":2,"name":"Dave"}],' \
'"name":"Alice Bob","website":"example.com"}'
assert sz.serialize(m1) == m1s.encode()
assert sz.serialize(m1, toBytes=False) == m1s
assert sz.serialize(m2) == m2s.encode()
assert sz.serialize(m2, toBytes=False) == m2s
assert sz.serialize(m3) == m3s.encode()
assert sz.serialize(m3, toBytes=False) == m3s
assert sz.deserialize(m1s) == m1
assert sz.deserialize(m1s.encode()) == m1
assert sz.deserialize(m2s) == m2
assert sz.deserialize(m2s.encode()) == m2
assert sz.deserialize(m3s) == m3
assert sz.deserialize(m3s.encode()) == m3
def test_domain_genesis_txns(bootstrap, domain_genesis_file):
serializer = JsonSerializer()
with open(domain_genesis_file) as f:
i = 0
for line in store_utils.cleanLines(f.readlines()):
txn = serializer.deserialize(line)
assert get_seq_no(txn)
assert get_payload_data(txn)
assert get_type(txn) == NYM
assert get_version(txn) == "1"
assert get_protocol_version(txn) is None
assert get_payload_data(txn)[VERKEY]
assert get_payload_data(txn)[TARGET_NYM]
assert ALIAS not in get_payload_data(txn)
# expect Trustees, then Stewards, then Clients
if 0 <= i < TRUSTEE_COUNT:
expected_role = TRUSTEE
elif TRUSTEE_COUNT <= i < TRUSTEE_COUNT + NODE_COUNT:
expected_role = STEWARD
else:
expected_role = None
assert get_payload_data(txn).get(ROLE) == expected_role
i += 1
class FeesAuthorizer(AbstractAuthorizer):
def __init__(self, config_state: PruningState, utxo_cache: UTXOCache):
super().__init__()
self.config_state = config_state
self.utxo_cache = utxo_cache
self.state_serializer = JsonSerializer()
@staticmethod
def has_fees(request) -> bool:
return hasattr(request, FEES) and request.fees is not None
@staticmethod
def get_change_for_fees(request) -> list:
return request.fees[1] if len(request.fees) >= 2 else []
@staticmethod
def calculate_fees_from_req(utxo_cache, request):
if hasattr(request, FEES):
inputs = request.fees[0]
outputs = FeesAuthorizer.get_change_for_fees(request)
else:
inputs = request.operation[INPUTS]
outputs = request.operation[OUTPUTS]
try:
sum_inputs = utxo_cache.sum_inputs(inputs, is_committed=False)
except Exception as e:
logger.error(
"Unexpected exception while sum_inputs calculating: {}".format(
e))
return 0
sum_outputs = sum([a[AMOUNT] for a in outputs])
return sum_inputs - sum_outputs
def can_pay_fees(self, request, required_fees):
try:
self._can_pay_fees(request, required_fees)
except (InvalidFundsError, UnauthorizedClientRequest, ExtraFundsError,
InsufficientFundsError, InvalidClientMessageException) as e:
return False, str(e)
return True, ''
def _can_pay_fees(self, request, required_fees):
if request.operation[TXN_TYPE] == XFER_PUBLIC:
# Fees in XFER_PUBLIC is part of operation[INPUTS]
inputs = request.operation[INPUTS]
outputs = request.operation[OUTPUTS]
self._validate_fees_can_pay(request, inputs, outputs,
required_fees)
else:
inputs = request.fees[0]
outputs = self.get_change_for_fees(request)
self._validate_fees_can_pay(request, inputs, outputs,
required_fees)
def _validate_fees_can_pay(self, request, inputs, outputs, required_fees):
"""
Calculate and verify that inputs and outputs for fees can both be paid and change is properly specified
This function ASSUMES that validation of the fees for the request has already been done.
:param request:
:param required_fees:
:return:
"""
try:
sum_inputs = self.utxo_cache.sum_inputs(inputs, is_committed=False)
except UTXOError as ex:
raise InvalidFundsError(request.identifier, request.reqId,
"{}".format(ex))
except Exception as ex:
error = 'Exception {} while processing inputs/outputs'.format(ex)
raise UnauthorizedClientRequest(request.identifier, request.reqId,
error)
else:
change_amount = sum([a[AMOUNT] for a in outputs])
expected_amount = change_amount + required_fees
TokenStaticHelper.validate_given_inputs_outputs(
sum_inputs, change_amount, expected_amount, request,
'fees: {}'.format(required_fees))
def _get_fees_alias_from_constraint(self, auth_constaint: AuthConstraint):
if auth_constaint.metadata:
if FEES_FIELD_NAME in auth_constaint.metadata:
return auth_constaint.metadata[FEES_FIELD_NAME]
def _get_fees_from_state(self):
key = build_path_for_set_fees()
serz = self.config_state.get(key, isCommitted=False)
if not serz:
return {}
return self.state_serializer.deserialize(serz)
def authorize(self,
request,
auth_constraint: AuthConstraint,
auth_action: AbstractAuthAction = None):
fees_alias = self._get_fees_alias_from_constraint(auth_constraint)
fees = self._get_fees_from_state()
fees_amount = fees.get(fees_alias, 0)
is_fees_required = fees_amount > 0
if request.txn_type != XFER_PUBLIC:
if is_fees_required and not self.has_fees(request):
logger.warning(
"Validation error: Fees are required for this txn type")
return False, "Fees are required for this txn type"
if not is_fees_required and self.has_fees(request) \
and self.calculate_fees_from_req(self.utxo_cache, request) > 0:
logger.warning(
"Validation error: Fees are not required for this txn type"
)
return False, "Fees are not required for this txn type"
if not is_fees_required and not self.has_fees(request):
return True, ""
return self.can_pay_fees(request, fees_amount)
