def settle_overdue_acceptances(
requestor_ethereum_address: str,
provider_ethereum_address: str,
acceptances: List[SubtaskResultsAccepted],
requestor_public_key: bytes,
) -> DepositClaim:
"""
The purpose of this operation is to calculate the total amount that the requestor owes provider for completed
computations and transfer that amount from requestor's deposit.
The caller is responsible for making sure that the payment is legitimate and should be performed.
Bankster simply calculates the amount and executes it.
"""
assert isinstance(requestor_ethereum_address, str)
assert isinstance(provider_ethereum_address, str)
assert all([
isinstance(acceptance, SubtaskResultsAccepted)
for acceptance in acceptances
])
assert len(requestor_ethereum_address) == ETHEREUM_ADDRESS_LENGTH
assert len(provider_ethereum_address) == ETHEREUM_ADDRESS_LENGTH
assert provider_ethereum_address != requestor_ethereum_address
validate_list_of_transaction_timestamp(acceptances)
requestor_client: Client = get_or_create_with_retry(
Client, public_key=requestor_public_key)
requestor_deposit_account: DepositAccount = get_or_create_with_retry(
DepositAccount,
client=requestor_client,
ethereum_address=requestor_ethereum_address)
# Bankster asks SCI about the amount of funds available in requestor's deposit.
requestor_deposit_value = service.get_deposit_value(
client_eth_address=requestor_ethereum_address) # pylint: disable=no-value-for-parameter
# Bankster begins a database transaction and puts a database lock on the DepositAccount object.
with non_nesting_atomic(using='control'):
DepositAccount.objects.select_for_update().get(
pk=requestor_deposit_account.pk)
# Bankster sums the amounts of all existing DepositClaims that have the same payer as the one being processed.
sum_of_existing_requestor_claims = DepositClaim.objects.filter(
payer_deposit_account=requestor_deposit_account).aggregate(
sum_of_existing_claims=Coalesce(Sum('amount'), 0))
# Concent defines time T0 equal to oldest payment_ts from passed SubtaskResultAccepted messages from
# subtask_results_accepted_list.
oldest_payments_ts = min(subtask_results_accepted.payment_ts
for subtask_results_accepted in acceptances)
# Concent gets list of forced payments from payment API where T0 <= payment_ts + PAYMENT_DUE_TIME.
list_of_settlement_payments = service.get_list_of_payments( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
min_block_timestamp=oldest_payments_ts,
transaction_type=TransactionType.SETTLEMENT,
)
already_satisfied_claims_without_duplicates = find_unconfirmed_settlement_payments(
list_of_settlement_payments,
requestor_deposit_account,
provider_ethereum_address,
oldest_payments_ts,
)
# Concent gets list of transactions from payment API where timestamp >= T0.
list_of_transactions = service.get_list_of_payments( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
min_block_timestamp=oldest_payments_ts,
transaction_type=TransactionType.BATCH,
)
(_amount_paid, amount_pending) = get_provider_payment_info(
list_of_settlement_payments=list_of_settlement_payments,
list_of_transactions=list_of_transactions,
settlement_payment_claims=
already_satisfied_claims_without_duplicates,
subtask_results_accepted_list=acceptances,
)
if amount_pending <= 0:
raise BanksterNoUnsettledTasksError()
# Bankster compares the amount with the available deposit minus the existing claims against requestor's account.
# If the whole amount can't be paid, Concent lowers it to pay as much as possible.
requestor_payable_amount = min(
amount_pending,
requestor_deposit_value -
sum_of_existing_requestor_claims['sum_of_existing_claims'],
)
logger.info(
f'requestor_payable_amount is {requestor_payable_amount} for ethereum address {requestor_ethereum_address}.'
)
if requestor_payable_amount <= 0:
raise BanksterTooSmallRequestorDepositError(
f"Requestor payable amount is {requestor_payable_amount}")
# This is time T2 (end time) equal to youngest payment_ts from passed SubtaskResultAccepted messages from
# subtask_results_accepted_list.
youngest_payment_ts = max(subtask_results_accepted.payment_ts
for subtask_results_accepted in acceptances)
# Deposit lock for requestor.
claim_against_requestor = DepositClaim(
payee_ethereum_address=provider_ethereum_address,
payer_deposit_account=requestor_deposit_account,
amount=requestor_payable_amount,
concent_use_case=ConcentUseCase.FORCED_PAYMENT,
tx_hash=None,
closure_time=parse_timestamp_to_utc_datetime(youngest_payment_ts),
)
claim_against_requestor.full_clean()
claim_against_requestor.save()
v_list, r_list, s_list, values, subtask_id_list = [], [], [], [], []
for subtask_results_accepted in acceptances:
v, r, s = subtask_results_accepted.task_to_compute.promissory_note_sig
v_list.append(v)
r_list.append(r)
s_list.append(s)
values.append(subtask_results_accepted.task_to_compute.price)
subtask_id_list.append(
subtask_results_accepted.task_to_compute.subtask_id)
transaction_hash = service.make_settlement_payment( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
value=values,
subtask_ids=subtask_id_list,
closure_time=youngest_payment_ts,
v=v_list,
r=r_list,
s=s_list,
reimburse_amount=claim_against_requestor.amount_as_int,
)
transaction_hash = adjust_transaction_hash(transaction_hash)
with non_nesting_atomic(using='control'):
claim_against_requestor.tx_hash = transaction_hash
claim_against_requestor.full_clean()
claim_against_requestor.save()
return claim_against_requestor
def finalize_payment(deposit_claim: DepositClaim) -> Optional[str]:
"""
This operation tells Bankster to pay out funds from deposit.
For each claim, Bankster uses SCI to submit an Ethereum transaction to the Ethereum client which then propagates it
to the rest of the network.
Hopefully the transaction is included in one of the upcoming blocks on the blockchain.
IMPORTANT!: This function must never be called in parallel for the same DepositClaim - otherwise provider might get
paid twice for the same thing. It's caller responsibility to ensure that.
"""
assert isinstance(deposit_claim, DepositClaim)
assert deposit_claim.tx_hash is None
# Bankster asks SCI about the amount of funds available on the deposit account listed in the DepositClaim.
available_funds = service.get_deposit_value( # pylint: disable=no-value-for-parameter
client_eth_address=deposit_claim.payer_deposit_account.ethereum_address
)
# Bankster begins a database transaction and puts a database lock on the DepositAccount object.
with non_nesting_atomic(using='control'):
DepositAccount.objects.select_for_update().get(
pk=deposit_claim.payer_deposit_account_id)
# Bankster sums the amounts of all existing DepositClaims that have the same payer as the one being processed.
aggregated_client_claims = DepositClaim.objects.filter(
payer_deposit_account=deposit_claim.payer_deposit_account).exclude(
pk=deposit_claim.pk).aggregate(
sum_of_existing_claims=Coalesce(Sum('amount'), 0))
# Bankster subtracts that value from the amount of funds available in the deposit.
available_funds_without_claims = available_funds - aggregated_client_claims[
'sum_of_existing_claims']
# If the result is negative or zero, Bankster removes the DepositClaim object being processed.
if available_funds_without_claims <= 0:
deposit_claim.delete()
return None
# Otherwise if the result is lower than DepositAccount.amount,
# Bankster sets this field to the amount that's actually available.
elif available_funds_without_claims < deposit_claim.amount:
deposit_claim.amount = available_funds_without_claims
deposit_claim.save()
# If the DepositClaim still exists at this point, Bankster uses SCI to create an Ethereum transaction.
subtask = Subtask.objects.filter(
subtask_id=deposit_claim.subtask_id).first() # pylint: disable=no-member
task_to_compute: TaskToCompute = deserialize_message(
subtask.task_to_compute.data.tobytes())
v, r, s = task_to_compute.promissory_note_sig
if deposit_claim.concent_use_case == ConcentUseCase.FORCED_ACCEPTANCE:
ethereum_transaction_hash = service.force_subtask_payment( # pylint: disable=no-value-for-parameter
requestor_eth_address=deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=deposit_claim.payee_ethereum_address,
value=task_to_compute.price,
subtask_id=deposit_claim.subtask_id,
v=v,
r=r,
s=s,
reimburse_amount=deposit_claim.amount_as_int,
)
elif deposit_claim.concent_use_case == ConcentUseCase.ADDITIONAL_VERIFICATION:
if subtask is not None:
if task_to_compute.requestor_ethereum_address == deposit_claim.payer_deposit_account.ethereum_address:
ethereum_transaction_hash = service.force_subtask_payment( # pylint: disable=no-value-for-parameter
requestor_eth_address=deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=deposit_claim.payee_ethereum_address,
value=task_to_compute.price,
subtask_id=deposit_claim.subtask_id,
v=v,
r=r,
s=s,
reimburse_amount=deposit_claim.amount_as_int,
)
elif task_to_compute.provider_ethereum_address == deposit_claim.payer_deposit_account.ethereum_address:
subtask_results_verify: SubtaskResultsVerify = deserialize_message(
subtask.subtask_results_verify.data.tobytes())
(v, r, s) = subtask_results_verify.concent_promissory_note_sig
ethereum_transaction_hash = service.cover_additional_verification_cost( # pylint: disable=no-value-for-parameter
provider_eth_address=deposit_claim.payer_deposit_account.
ethereum_address,
value=subtask_results_verify.task_to_compute.price,
subtask_id=deposit_claim.subtask_id,
v=v,
r=r,
s=s,
reimburse_amount=deposit_claim.amount_as_int,
)
else:
assert False
else:
assert False
with non_nesting_atomic(using='control'):
# The code below is executed in another transaction, so - in theory - deposit_claim object could be modified in
# the meantime. Here we are working under assumption that it's not the case and it is coder's responsibility to
# ensure that.
ethereum_transaction_hash = adjust_transaction_hash(
ethereum_transaction_hash)
deposit_claim.tx_hash = ethereum_transaction_hash
deposit_claim.full_clean()
deposit_claim.save()
service.register_confirmed_transaction_handler( # pylint: disable=no-value-for-parameter
tx_hash=deposit_claim.tx_hash,
callback=lambda _: discard_claim(deposit_claim),
)
return deposit_claim.tx_hash
def settle_overdue_acceptances(
requestor_ethereum_address: str,
provider_ethereum_address: str,
acceptances: List[SubtaskResultsAccepted],
requestor_public_key: bytes,
) -> Optional[DepositClaim]:
"""
The purpose of this operation is to calculate the total amount that the requestor owes provider for completed
computations and transfer that amount from requestor's deposit.
The caller is responsible for making sure that the payment is legitimate and should be performed.
Bankster simply calculates the amount and executes it.
"""
assert isinstance(requestor_ethereum_address, str)
assert isinstance(provider_ethereum_address, str)
assert all([
isinstance(acceptance, SubtaskResultsAccepted)
for acceptance in acceptances
])
assert len(requestor_ethereum_address) == ETHEREUM_ADDRESS_LENGTH
assert len(provider_ethereum_address) == ETHEREUM_ADDRESS_LENGTH
assert provider_ethereum_address != requestor_ethereum_address
with transaction.atomic(using='control'):
try:
requestor_client = Client.objects.get_or_create_full_clean(
public_key=requestor_public_key, )
except IntegrityError as exception:
if exception.pgcode == pg_errorcodes.UNIQUE_VIOLATION:
requestor_client = Client.objects.get_or_create_full_clean(
public_key=requestor_public_key, )
else:
raise
with transaction.atomic(using='control'):
try:
requestor_deposit_account = DepositAccount.objects.get_or_create_full_clean(
client=requestor_client,
ethereum_address=requestor_ethereum_address,
)
except IntegrityError as exception:
if exception.pgcode == pg_errorcodes.UNIQUE_VIOLATION:
requestor_deposit_account = DepositAccount.objects.get_or_create_full_clean(
client=requestor_client,
ethereum_address=requestor_ethereum_address,
)
else:
raise
# Bankster asks SCI about the amount of funds available in requestor's deposit.
requestor_deposit_value = service.get_deposit_value(
client_eth_address=requestor_ethereum_address) # pylint: disable=no-value-for-parameter
# Bankster begins a database transaction and puts a database lock on the DepositAccount object.
with transaction.atomic(using='control'):
DepositAccount.objects.select_for_update().get(
pk=requestor_deposit_account.pk)
# Bankster sums the amounts of all existing DepositClaims that have the same payer as the one being processed.
sum_of_existing_requestor_claims = DepositClaim.objects.filter(
payer_deposit_account=requestor_deposit_account).aggregate(
sum_of_existing_claims=Coalesce(Sum('amount'), 0))
assert sum_of_existing_requestor_claims['sum_of_existing_claims'] >= 0
# If the existing claims against requestor's deposit are greater or equal to his current deposit,
# we can't add a new claim.
if requestor_deposit_value <= sum_of_existing_requestor_claims[
'sum_of_existing_claims']:
return None
# Concent defines time T0 equal to oldest payment_ts from passed SubtaskResultAccepted messages from
# subtask_results_accepted_list.
oldest_payments_ts = min(subtask_results_accepted.payment_ts
for subtask_results_accepted in acceptances)
cut_off_time = get_current_utc_timestamp()
# Concent gets list of transactions from payment API where timestamp >= T0.
list_of_transactions = service.get_list_of_payments( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
payment_ts=oldest_payments_ts,
transaction_type=TransactionType.BATCH,
)
validate_list_of_transactions_timestamps(list_of_transactions,
cut_off_time, acceptances)
# Concent gets list of forced payments from payment API where T0 <= payment_ts + PAYMENT_DUE_TIME.
list_of_forced_payments = service.get_list_of_payments( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
payment_ts=oldest_payments_ts,
transaction_type=TransactionType.FORCE,
)
(_amount_paid, amount_pending) = get_provider_payment_info(
list_of_forced_payments=list_of_forced_payments,
list_of_payments=list_of_transactions,
subtask_results_accepted_list=acceptances,
)
# Bankster compares the amount with the available deposit minus the existing claims against requestor's account.
# If the whole amount can't be paid, Concent lowers it to pay as much as possible.
requestor_payable_amount = min(
amount_pending,
requestor_deposit_value -
sum_of_existing_requestor_claims['sum_of_existing_claims'],
)
logger.info(
f'requestor_payable_amount is {requestor_payable_amount} for ethereum address {requestor_ethereum_address}.'
)
if requestor_payable_amount <= 0:
return None
transaction_hash = service.make_force_payment_to_provider( # pylint: disable=no-value-for-parameter
requestor_eth_address=requestor_ethereum_address,
provider_eth_address=provider_ethereum_address,
value=requestor_payable_amount,
payment_ts=cut_off_time,
)
transaction_hash = adjust_transaction_hash(transaction_hash)
# Deposit lock for requestor.
claim_against_requestor = DepositClaim(
payee_ethereum_address=provider_ethereum_address,
payer_deposit_account=requestor_deposit_account,
amount=requestor_payable_amount,
concent_use_case=ConcentUseCase.FORCED_PAYMENT,
tx_hash=transaction_hash,
)
claim_against_requestor.full_clean()
claim_against_requestor.save()
return claim_against_requestor
def test_that_adjust_transaction_hash_cut_0x_prefix_correctly(self, transaction_hash, expected_result):
result = adjust_transaction_hash(transaction_hash)
assert_that(expected_result).is_equal_to(result)
def finalize_payment(deposit_claim: DepositClaim) -> Optional[str]:
"""
This operation tells Bankster to pay out funds from deposit.
For each claim, Bankster uses SCI to submit an Ethereum transaction to the Ethereum client which then propagates it
to the rest of the network.
Hopefully the transaction is included in one of the upcoming blocks on the blockchain.
"""
assert isinstance(deposit_claim, DepositClaim)
# Bankster asks SCI about the amount of funds available on the deposit account listed in the DepositClaim.
available_funds = service.get_deposit_value( # pylint: disable=no-value-for-parameter
client_eth_address=deposit_claim.payer_deposit_account.ethereum_address
)
# Bankster begins a database transaction and puts a database lock on the DepositAccount object.
with transaction.atomic(using='control'):
DepositAccount.objects.select_for_update().get(
pk=deposit_claim.payer_deposit_account_id)
# Bankster sums the amounts of all existing DepositClaims that have the same payer as the one being processed.
aggregated_client_claims = DepositClaim.objects.filter(
payer_deposit_account=deposit_claim.payer_deposit_account).exclude(
pk=deposit_claim.pk).aggregate(
sum_of_existing_claims=Coalesce(Sum('amount'), 0))
# Bankster subtracts that value from the amount of funds available in the deposit.
available_funds_without_claims = available_funds - aggregated_client_claims[
'sum_of_existing_claims']
# If the result is negative or zero, Bankster removes the DepositClaim object being processed.
if available_funds_without_claims <= 0:
deposit_claim.delete()
return None
# Otherwise if the result is lower than DepositAccount.amount,
# Bankster sets this field to the amount that's actually available.
elif available_funds_without_claims < deposit_claim.amount:
deposit_claim.amount = available_funds_without_claims
# If the DepositClaim still exists at this point, Bankster uses SCI to create an Ethereum transaction.
if deposit_claim.concent_use_case == ConcentUseCase.FORCED_ACCEPTANCE:
ethereum_transaction_hash = service.force_subtask_payment( # pylint: disable=no-value-for-parameter
requestor_eth_address=deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=deposit_claim.payee_ethereum_address,
value=deposit_claim.amount,
subtask_id=deposit_claim.subtask_id,
)
elif deposit_claim.concent_use_case == ConcentUseCase.ADDITIONAL_VERIFICATION:
subtask = Subtask.objects.filter(
subtask_id=deposit_claim.subtask_id).first() # pylint: disable=no-member
if subtask is not None:
task_to_compute = deserialize_message(
subtask.task_to_compute.data.tobytes())
if task_to_compute.requestor_ethereum_address == deposit_claim.payer_deposit_account.ethereum_address:
ethereum_transaction_hash = service.force_subtask_payment( # pylint: disable=no-value-for-parameter
requestor_eth_address=deposit_claim.
payer_deposit_account.ethereum_address,
provider_eth_address=deposit_claim.
payee_ethereum_address,
value=deposit_claim.amount,
subtask_id=deposit_claim.subtask_id,
)
elif task_to_compute.provider_ethereum_address == deposit_claim.payer_deposit_account.ethereum_address:
ethereum_transaction_hash = service.cover_additional_verification_cost( # pylint: disable=no-value-for-parameter
provider_eth_address=deposit_claim.
payer_deposit_account.ethereum_address,
value=deposit_claim.amount,
subtask_id=deposit_claim.subtask_id,
)
else:
assert False
else:
assert False
# Bankster puts transaction ID in DepositClaim.tx_hash.
ethereum_transaction_hash = adjust_transaction_hash(
ethereum_transaction_hash)
deposit_claim.tx_hash = ethereum_transaction_hash
deposit_claim.full_clean()
deposit_claim.save()
service.call_on_confirmed_transaction( # pylint: disable=no-value-for-parameter
tx_hash=deposit_claim.tx_hash,
callback=lambda _: discard_claim(deposit_claim),
)
return deposit_claim.tx_hash