def can_pay_fees(self, request):
required_fees = self.get_txn_fees(request)
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)
self.deducted_fees_xfer[request.key] = required_fees
elif required_fees:
if StaticFeesReqHandler.has_fees(request):
inputs = request.fees[0]
outputs = self.get_change_for_fees(request)
self._validate_fees_can_pay(request, inputs, outputs,
required_fees)
else:
raise InvalidClientMessageException(
getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None),
'Fees are required for this txn type')
else:
if StaticFeesReqHandler.has_fees(request):
raise InvalidClientMessageException(
getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None),
'Fees are not allowed for this txn type')
def _fees_specific_validation(self, request: Request):
operation = request.operation
current_fees = self._get_fees()
constraint = self.get_auth_constraint(operation)
wrong_aliases = []
self._validate_metadata(self.fees, constraint, wrong_aliases)
if len(wrong_aliases) > 0:
raise InvalidClientMessageException(
request.identifier, request.reqId,
"Fees alias(es) {} does not exist in current fees {}. "
"Please add the alias(es) via SET_FEES transaction first.".
format(", ".join(wrong_aliases), current_fees))
def validate(self, request: Request):
req_type = request.operation[TXN_TYPE]
if req_type == MINT_PUBLIC:
return validate_multi_sig_txn(request, TRUSTEE, self.domain_state,
self.MinSendersForPublicMint)
elif req_type == XFER_PUBLIC:
return self.handle_xfer_public_txn(request)
raise InvalidClientMessageException(
request.identifier, getattr(request, 'reqId', None),
'Unsupported request type - {}'.format(req_type))
def validate(self, request: Request):
req_type = request.operation[TXN_TYPE]
if req_type == MINT_PUBLIC:
return self.write_req_validator.validate(
request,
[AuthActionAdd(txn_type=MINT_PUBLIC, field="*", value="*")])
elif req_type == XFER_PUBLIC:
self.handle_xfer_public_txn(request)
return self.write_req_validator.validate(
request,
[AuthActionAdd(txn_type=XFER_PUBLIC, field="*", value="*")])
raise InvalidClientMessageException(
request.identifier, getattr(request, 'reqId', None),
'Unsupported request type - {}'.format(req_type))
def _do_validate_inputs_ouputs(self, request):
try:
sum_in = TokenStaticHelper.sum_inputs(self.utxo_cache,
request,
is_committed=False)
sum_out = TokenStaticHelper.sum_outputs(request)
except Exception as ex:
if isinstance(ex, InvalidClientMessageException):
raise ex
error = 'Exception {} while processing inputs/outputs'.format(ex)
raise InvalidClientMessageException(
request.identifier, getattr(request, 'reqId', None), error)
else:
return TokenStaticHelper.validate_given_inputs_outputs(
sum_in, sum_out, sum_out, request)
def fees_specific_validation(self, request: Request):
operation = request.operation
current_fees = self._get_fees_handler.get_fees()
constraints = []
for rule in operation[RULES]:
constraints.append(StaticAuthRuleHelper.get_auth_constraint(rule))
for constraint in constraints:
wrong_aliases = []
AuthRuleFeeHandler.validate_metadata(current_fees, constraint,
wrong_aliases)
if len(wrong_aliases) > 0:
raise InvalidClientMessageException(
request.identifier, request.reqId,
"Fees alias(es) {} does not exist in current fees {}. "
"Please add the alias(es) via SET_FEES transaction first.".
format(", ".join(wrong_aliases), current_fees))
def handle_xfer_public_txn(self, request):
# Currently only sum of inputs is matched with sum of outputs. If anything more is
# needed then a new function should be created.
try:
sum_inputs = TokenReqHandler.sum_inputs(self.utxo_cache,
request,
is_committed=False)
sum_outputs = TokenReqHandler.sum_outputs(request)
except Exception as ex:
if isinstance(ex, InvalidClientMessageException):
raise ex
error = 'Exception {} while processing inputs/outputs'.format(ex)
raise InvalidClientMessageException(
request.identifier, getattr(request, 'reqId', None), error)
else:
return TokenReqHandler._validate_xfer_public_txn(
request, sum_inputs, sum_outputs)
def validate_given_inputs_outputs(inputs_sum,
outputs_sum,
required_amount,
request,
error_msg_suffix: Optional[str] = None):
"""
Checks three sum values against simple set of rules. inputs_sum must be equal to required_amount. Exceptions
are raise if it is not equal. The outputs_sum is pass not for checks but to be included in error messages.
This is confusing but is required in cases where the required amount is different then the sum of outputs (
in the case of fees).
:param inputs_sum: the sum of inputs
:param outputs_sum: the sum of outputs
:param required_amount: the required amount to validate (could be equal to output_sum, but may be different)
:param request: the request that is being validated
:param error_msg_suffix: added message to the error message
:return: returns if valid or will raise an exception
"""
if inputs_sum == required_amount:
return # Equal is valid
elif inputs_sum > required_amount:
error = 'Extra funds, sum of inputs is {} ' \
'but required amount: {} -- sum of outputs: {}'.format(inputs_sum, required_amount, outputs_sum)
if error_msg_suffix and isinstance(error_msg_suffix, str):
error += ' ' + error_msg_suffix
raise ExtraFundsError(getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None), error)
elif inputs_sum < required_amount:
error = 'Insufficient funds, sum of inputs is {} ' \
'but required amount is {}. sum of outputs: {}'.format(inputs_sum, required_amount, outputs_sum)
if error_msg_suffix and isinstance(error_msg_suffix, str):
error += ' ' + error_msg_suffix
raise InsufficientFundsError(
getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None), error)
raise InvalidClientMessageException(
getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None),
'Request to not meet minimum requirements')
def can_pay_fees(self, request):
required_fees = self.get_txn_fees(request)
if self.has_fees(request) and not required_fees:
raise InvalidClientMessageException(getattr(request, f.IDENTIFIER.nm, None),
getattr(request, f.REQ_ID.nm, None),
'Fees are not allowed for this txn type')
if request.operation[TXN_TYPE] == XFER_PUBLIC:
# Fees in XFER_PUBLIC is part of operation[INPUTS]
self._get_deducted_fees_xfer(request, required_fees)
self.deducted_fees_xfer[request.key] = required_fees
elif required_fees:
# We don't want to allow transfers on txn fees. So only one OUTPUT address can be used.
# We could consider lock this down even more by requiring OUTPUT address to be one of the
# INPUT address
outputs = request.fees[1]
if len(outputs) > MAX_FEE_OUTPUTS:
raise InvalidClientRequest(request.identifier,
request.reqId,
"Only {} OUTPUT is allow for Transaction fees".format(MAX_FEE_OUTPUTS))
self._get_deducted_fees_non_xfer(request, required_fees)
def randomDynamicValidation(self, req, pp_time):
req_keys = [fake_req.key for fake_req in fake_requests]
if req_keys.index(req.key) % 2:
raise InvalidClientMessageException('aaaaaaaa', req.reqId,
"not valid req")
def raise_invalid_ex():
raise InvalidClientMessageException(1, 2, 3)
def randomDynamicValidation(self, req):
if list(self.replica.requests.keys()).index(req.key) % 2:
raise InvalidClientMessageException('aaaaaaaa',
req.reqId,
"not valid req")
def randomDynamicValidation(self, req, ppTime):
raise InvalidClientMessageException('aaaaaaaa', req.reqId, "not valid req")
