From c4108bbf5bca63aed0e7d7392e57006fea4d26d2 Mon Sep 17 00:00:00 2001 From: Zhang Pluto Date: Thu, 1 Feb 2024 14:42:23 -0500 Subject: [PATCH 01/10] have more status about task --- backend/model/task.py | 3 +- backend/router/deploy_info.py | 4 +-- backend/router/user.py | 4 ++- backend/router/validate.py | 33 +++++++++++++++---- backend/service/computing_provider_service.py | 11 +++++++ backend/service/space_service.py | 31 +++++++++-------- backend/utils/constant.py | 3 ++ contracts/abi/Task.json | 13 ++++++++ 8 files changed, 78 insertions(+), 24 deletions(-) diff --git a/backend/model/task.py b/backend/model/task.py index 26ecaf44..d9d9bcce 100644 --- a/backend/model/task.py +++ b/backend/model/task.py @@ -18,6 +18,7 @@ class Task(db.Model): end_at = db.Column(db.String(64)) created_at = db.Column(db.String(64)) updated_at = db.Column(db.String(64)) + refund_wallet = db.Column(db.String(255)) def to_dict(self): return { @@ -28,7 +29,7 @@ def to_dict(self): "task_detail_cid": self.task_detail_cid, "created_at": self.created_at, "updated_at": self.updated_at, - "end_at": self.end_at, + "end_at": self.end_at } def get_task_by_uuid(uuid): diff --git a/backend/router/deploy_info.py b/backend/router/deploy_info.py index 54d47a9a..83064074 100644 --- a/backend/router/deploy_info.py +++ b/backend/router/deploy_info.py @@ -102,13 +102,13 @@ def deploy_with_space_url(): response.status = constant.STATUS_SUCCESS return jsonify(response.to_dict()), HTTPStatus.OK except Exception as err: - # Return Internal Error if any issue comesup + # Return Internal Error if any issue comes up # TODO: FIX logging.info( f"Error during Task generation Error: {str(err)} {traceback.format_exc()}" ) response.message = "Error during task_uuid generation." - response.status = "error" + response.status = constant.STATUS_FAILED return jsonify(response.to_dict()), HTTPStatus.INTERNAL_SERVER_ERROR diff --git a/backend/router/user.py b/backend/router/user.py index bfd0da20..d2e2168d 100644 --- a/backend/router/user.py +++ b/backend/router/user.py @@ -2,8 +2,9 @@ from http import HTTPStatus from flask import jsonify, Blueprint, request +from flask_jwt_extended import jwt_required -from backend.middleware.token_service import jwt_or_api_token_required, get_jwt_identity +from backend.middleware.token_service import jwt_or_api_token_required, get_jwt_identity, jwt_or_api_token_required2 from backend.model.response import Response from backend.model.user import User from backend.service import user_service @@ -96,6 +97,7 @@ def check_provider_payment(): response.status = constant.STATUS_SUCCESS return jsonify(response.to_dict()), 200 + @user_bp.route("/jwt_info", methods=["GET"]) @jwt_or_api_token_required def check_wallet_address(): diff --git a/backend/router/validate.py b/backend/router/validate.py index 6df2e870..7c0e1566 100644 --- a/backend/router/validate.py +++ b/backend/router/validate.py @@ -9,7 +9,7 @@ from flask import jsonify, Blueprint, request from sqlalchemy.exc import DatabaseError, OperationalError -from backend.middleware.token_service import jwt_or_api_token_required +from backend.middleware.token_service import jwt_or_api_token_required, jwt_or_api_token_required2 from backend.model import db from backend.model.common import update_record from backend.model.computing_provider import ComputingProvider @@ -20,7 +20,8 @@ from backend.service import space_service # Internal models from backend.service.space_service import get_payment_info -from backend.service.computing_provider_service import get_balance, get_task_collateral_balance +from backend.service.computing_provider_service import get_balance, get_task_collateral_balance, get_contract_end_time +from backend.service.user_service import get_user_by_address from backend.utils import constant validate_bp = Blueprint("validate_bp", __name__) @@ -184,12 +185,12 @@ def claim_review(): @validate_bp.route("/terminate_task", methods=["POST"]) @jwt_or_api_token_required -def task_refund(): +def task_termination(): """ Desc: Post request which takes in form data: task_uuid(str): The task which is being terminated - refund_wallet(str): which user will receieve the refund + refund_wallet(str): which user will receive the refund Returns: Success/failed if the termination of the task succeeded or not """ @@ -224,6 +225,10 @@ def task_refund(): response.message = "Task is not started yet" return jsonify(response.to_dict()), 200 + # Update task refund wallet + task.refund_wallet = refund_wallet + task = update_record(task, db.session) + # check if jobs are CANCELLED OR CANCELLED FAILED jobs = Job.get_all_jobs_by_task_uuid(task_uuid) cancel_status = None @@ -247,9 +252,19 @@ def task_refund(): if cancel_status: # First time try release collateral try: + # Set User + txn_hash = space_service.set_user(refund_wallet, task_uuid) + if txn_hash is None: + task.status = constant.SET_USER_FAILED + task = update_record(task, db.session) + response.message = "Set user failed on contract side" + response.status = constant.SUCCESS + return jsonify(response.to_dict()), 200 # Update end_time on contract side txn_hash = space_service.update_end_time(task_uuid, task.end_at) if txn_hash is None: + task.status = constant.UPDATE_END_TIME_FAILED + task = update_record(task, db.session) response.message = ( "Task has been terminate on CP side, but the Txn hash is None, update end time failed " "on contract side") @@ -259,6 +274,8 @@ def task_refund(): txn_hash = space_service.unlock_collateral(task_uuid) if txn_hash is None: + task.status = constant.COLLATERAL_NOT_RELEASED + task = update_record(task, db.session) response.message = ("Txn hash is None, unlock collateral failed " "on contract side") response.status = constant.SUCCESS @@ -271,9 +288,13 @@ def task_refund(): # Update status for scheduler if collateral balance is not released collateral_balance = get_task_collateral_balance(task_uuid) - logging.info(f"Collateral balance for task {task_uuid} is {collateral_balance}, {collateral_balance == 0}") if collateral_balance == 0: - task.status = constant.CAN_BE_CLAIMED + task.status = constant.COLLATERAL_RELEASED + end_at_time = get_contract_end_time(task_uuid) + if end_at_time != 0: + task.status = constant.CAN_BE_CLAIMED + else: + task.status = constant.UPDATE_END_TIME_FAILED else: task.status = constant.COLLATERAL_NOT_RELEASED task = update_record(task, db.session) diff --git a/backend/service/computing_provider_service.py b/backend/service/computing_provider_service.py index 0f56053d..1e42fa1a 100644 --- a/backend/service/computing_provider_service.py +++ b/backend/service/computing_provider_service.py @@ -323,6 +323,17 @@ def get_task_collateral_balance(task_uuid): return balance +def get_contract_end_time(task_uuid): + chain_id = "2024" + try: + w3, task_contract_address, task_contract, tx_config = verify_task_contract_address(chain_id, task_uuid) + except Exception as e: + logging.error(f"Error occurred when getting task contact: {str(e)}") + return None + end_time = task_contract.functions.endTime().call() + return end_time + + def extend_job(duration, bidder_id, task_uuid, job): cp = ComputingProvider.query.filter_by(node_id=bidder_id).first() uri = multiaddress_to_url(cp.multi_address, constant.EXTEND_JOB) diff --git a/backend/service/space_service.py b/backend/service/space_service.py index 4102ecd1..086bd300 100644 --- a/backend/service/space_service.py +++ b/backend/service/space_service.py @@ -291,20 +291,6 @@ def check_space_deployment_requests(space): logging.error(error_msg) -# def cancel_all_spaces_running_jobs(space): -# if space.task_uuid is None: -# Exception("Cancelling a space that is not currently running") -# -# jobs = Job.get_all_jobs_by_task_uuid(space.task_uuid) -# for job in jobs: -# if job.status != constant.JOB_RUNNING: -# continue -# job = cancel_space_job_and_task(job, space) -# # Job is now complete -# if job.status == constant.JOB_CANCELLED: -# Job.complete_job(job) - - def save_space_config_order(config, duration, region, start_in, order_type=None): cfg = ConfigOrder.create_config_order( config.id, duration, region, start_in, order_type @@ -645,6 +631,23 @@ def unlock_collateral(task_uuid): return tx_hash.hex() +def set_user(wallet_address, task_uuid): + logging.info("--------------------setting user-------------------") + chain_id = "2024" + try: + w3, task_contract_address, task_contract, tx_config = verify_task_contract_address(chain_id, task_uuid) + except Exception as e: + logging.error(f"Error occurred when getting task contact: {str(e)}") + return None + tx = task_contract.functions.setUser(wallet_address).build_transaction( + tx_config + ) + signed_tx = w3.eth.account.sign_transaction(tx, PRIVATE_ADDRESS) + tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction) + tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash) + return tx_hash.hex() + + def get_leading_cp(task_uuid): chain_id = "2024" try: diff --git a/backend/utils/constant.py b/backend/utils/constant.py index ce7f96d4..f31da4ba 100644 --- a/backend/utils/constant.py +++ b/backend/utils/constant.py @@ -153,6 +153,9 @@ COLLATERAL_RELEASED = "collateral_released" CAN_BE_CLAIMED = "can_be_claimed" TASK_CANCEL_FAILED = "cancel_failed" +SET_USER_FAILED = "set_user_failed" +UPDATE_END_TIME_FAILED = "update_end_time_failed" + # Refund status NON_REFUNDABLE = "Non-refundable" diff --git a/contracts/abi/Task.json b/contracts/abi/Task.json index 5eafa128..b658739a 100644 --- a/contracts/abi/Task.json +++ b/contracts/abi/Task.json @@ -479,6 +479,19 @@ "stateMutability": "view", "type": "function" }, + { + "inputs": [ + { + "internalType": "address", + "name": "userAddress", + "type": "address" + } + ], + "name": "setUser", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, { "inputs": [], "name": "startTime", From 3a3c5caf7f55f456bb970caae4b450302be03bb3 Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Sun, 4 Feb 2024 01:29:48 -0500 Subject: [PATCH 02/10] Update /provider/payments api return api token --- backend/router/auth.py | 4 +++- backend/router/user.py | 22 +++++++++++----------- backend/service/user_service.py | 4 ++-- 3 files changed, 16 insertions(+), 14 deletions(-) diff --git a/backend/router/auth.py b/backend/router/auth.py index 81dbcdef..af57a5df 100644 --- a/backend/router/auth.py +++ b/backend/router/auth.py @@ -38,8 +38,10 @@ def login(): if signer == public_address: user: User = User.get_user_by_address(public_address) + api_token = None if user: logging.info("[+] Found user " + user.public_address) + api_token = ApiToken.query.filter_by(user_id=user.id).first() else: user = User(public_address=public_address) db.session.add(user) @@ -50,7 +52,7 @@ def login(): access_token = create_access_token(identity=public_address) - resp = jsonify(access_token=access_token) + resp = jsonify(access_token=access_token, api_token=api_token.token if api_token else None) return resp, 200 diff --git a/backend/router/user.py b/backend/router/user.py index d2e2168d..29758ed5 100644 --- a/backend/router/user.py +++ b/backend/router/user.py @@ -60,8 +60,8 @@ def claim_provider_payment(): @user_bp.route("/provider/payments", methods=["GET"]) -@jwt_or_api_token_required -def check_provider_payment(): +@jwt_or_api_token_required2 +def check_provider_payment(user): """ Claim a provider payment associated with the user. @@ -73,19 +73,19 @@ def check_provider_payment(): """ response = Response(constant.STATUS_FAILED) response.data = {"payments": []} - limit = 10 - if request.args.get("limit") is not None and request.args.get("limit").isdigit(): - limit = int(request.args.get("limit")) - - offset = 0 - if request.args.get("offset") is not None and request.args.get("offset").isdigit(): - offset = int(request.args.get("offset")) - user = User.get_user_by_address(get_jwt_identity()) + # limit = 10 + # if request.args.get("limit") is not None and request.args.get("limit").isdigit(): + # limit = int(request.args.get("limit")) + # + # offset = 0 + # if request.args.get("offset") is not None and request.args.get("offset").isdigit(): + # offset = int(request.args.get("offset")) if user is None: response.message = "User not found" response.status = constant.STATUS_FAILED return jsonify(response.to_dict()), 200 - payments = user_service.get_user_provider_payments(user, limit, offset) + # payments = user_service.get_user_provider_payments(user, limit, offset) + payments = user_service.get_user_provider_payments(user) if payments is None: response.message = "No payments found" response.status = constant.SUCCESS diff --git a/backend/service/user_service.py b/backend/service/user_service.py index 8ec654a1..a5a5b9dc 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -26,8 +26,8 @@ def user_has_role(user, role_name): return role_name in roles -def get_user_provider_payments(user, limit, offset): - return ProviderPayment.get_by_owner_address(user.public_address).limit(limit).offset(offset).all() +def get_user_provider_payments(user): + return ProviderPayment.get_by_owner_address(user.public_address) def mark_payment_as_refunded(tx_hash, chain_id, user): From f1294ef4730fd1ed5b8962f6fd2781eb90e275bd Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Sun, 4 Feb 2024 01:52:45 -0500 Subject: [PATCH 03/10] Update /provider/payments api return api token --- backend/router/user.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/backend/router/user.py b/backend/router/user.py index 29758ed5..46d008b9 100644 --- a/backend/router/user.py +++ b/backend/router/user.py @@ -93,6 +93,8 @@ def check_provider_payment(user): else: for payment in payments: response.data["payments"].append(payment.to_dict()) + # 倒叙返回response.data["payments"] + response.data["payments"] = response.data["payments"][::-1] response.message = "successfully retrieved payments" response.status = constant.STATUS_SUCCESS return jsonify(response.to_dict()), 200 From 50f062b9b4846273c235f977604830f5245d19dc Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Sun, 4 Feb 2024 02:00:44 -0500 Subject: [PATCH 04/10] get provider payment desc --- backend/model/provider_payment.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/backend/model/provider_payment.py b/backend/model/provider_payment.py index b7643434..589e2713 100644 --- a/backend/model/provider_payment.py +++ b/backend/model/provider_payment.py @@ -77,7 +77,7 @@ def create_provider_payment( def get_by_owner_address(wallet_address): return ProviderPayment.query.filter_by( provider_owner_address=wallet_address - ).all() + ).order_by(ProviderPayment.provider_owner_address.desc()).all() def get_by_order_id(order_id): return ProviderPayment.query.filter_by(order_id=order_id).first() From 1eafa954cfaec04a89826c743428f56bba54006e Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 00:55:03 -0500 Subject: [PATCH 05/10] Script for release collateral --- backend/model/provider_payment.py | 5 ++ backend/service/user_service.py | 4 ++ script/update_task_contract.py | 95 +++++++++++++++++++++++++++++++ 3 files changed, 104 insertions(+) create mode 100644 script/update_task_contract.py diff --git a/backend/model/provider_payment.py b/backend/model/provider_payment.py index 589e2713..b12a9985 100644 --- a/backend/model/provider_payment.py +++ b/backend/model/provider_payment.py @@ -79,6 +79,11 @@ def get_by_owner_address(wallet_address): provider_owner_address=wallet_address ).order_by(ProviderPayment.provider_owner_address.desc()).all() + def get_all_provider_payments(): + return ProviderPayment.query.filter_by( + status="pending_reward" + ).all() + def get_by_order_id(order_id): return ProviderPayment.query.filter_by(order_id=order_id).first() diff --git a/backend/service/user_service.py b/backend/service/user_service.py index a5a5b9dc..344b4d28 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -30,6 +30,10 @@ def get_user_provider_payments(user): return ProviderPayment.get_by_owner_address(user.public_address) +def get_user_provider_payment_after_saturn(order_id): + return ProviderPayment.get_by_owner_address(order_id).filter(ProviderPayment.created_at > 1705986000).all() + + def mark_payment_as_refunded(tx_hash, chain_id, user): payment = SpacePayment.get_payment_by_tx_hash(tx_hash, chain_id, user.id) if payment is None: diff --git a/script/update_task_contract.py b/script/update_task_contract.py new file mode 100644 index 00000000..6d95652c --- /dev/null +++ b/script/update_task_contract.py @@ -0,0 +1,95 @@ +import json +import logging +import os +import web3 + +from backend import app, db +from backend.model.common import update_record +from backend.model.job import Job +from backend.model.provider_payment import ProviderPayment +from backend.utils.common import PUBLIC_ADDRESS, BIDDING_CONTRACT_ADDRESS, get_rpc + + +def update_task_contract(): + with app.app_context(): + # Get all the contracts that status is 'rewardable' + payment = ProviderPayment.get_all_provider_payments() + for p in payment: + job_id = p.job_id + print(f"job_id: {job_id}") + job = Job.get_job_by_id(job_id) + task_uuid = job.task_uuid + wallet_address = p.provider_owner_address + chain_id = "2024" + try: + w3 = get_rpc(chain_id) + # Get latest block's base fee + base_fee = w3.eth.get_block('latest')['baseFeePerGas'] + max_priority_fee_per_gas = w3.toWei(2, 'gwei') + max_fee_per_gas = base_fee + max_priority_fee_per_gas + if max_fee_per_gas < max_priority_fee_per_gas: + max_fee_per_gas = max_priority_fee_per_gas + base_fee + + bidding_contract = w3.eth.contract( + address=BIDDING_CONTRACT_ADDRESS, abi=json.load(open("../contracts/abi/Bidding.json")) + ) + task_contract_address = bidding_contract.functions.tasks(task_uuid).call() + if task_contract_address == "0x0000000000000000000000000000000000000000": + raise Exception("Task contract address is 0x0") + pass + task_contract = w3.eth.contract( + address=task_contract_address, abi=json.load(open("../contracts/abi/Task.json")) + ) + nonce = w3.eth.get_transaction_count(PUBLIC_ADDRESS) + tx_config = { + "from": PUBLIC_ADDRESS, + "nonce": nonce, + "maxFeePerGas": max_fee_per_gas, + "maxPriorityFeePerGas": max_priority_fee_per_gas, + } + + except Exception as e: + logging.error(f"Error occurred when getting task contact: {str(e)}") + pass + + try: + if task_contract.functions.refundDeadline().call() == 0: + tx = task_contract.functions.completeTask(wallet_address).build_transaction( + tx_config + ) + PRIVATE_ADDRESS = os.getenv("PRIVATE_ADDRESS") + signed_tx = w3.eth.account.sign_transaction(tx, PRIVATE_ADDRESS) + print(f"signed_tx: {signed_tx}") + tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction) + print(f"tx_hash: {tx_hash.hex()}") + tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash) + print(f"tx_receipt: {tx_receipt}") + + if tx_receipt.status == 0: + logging.error(f"Error occurred when getting task contact: {p.job_id}") + return None + else: + p.status = "rewardable" + update_record(p, db.session) + logging.info( + f"Successfully sent reward to {p.provider_owner_address}, tx hash: {tx_hash.hex()}") + else: + p.status = "rewardable" + update_record(p, db.session) + logging.info(f"Successfully sent reward to {p.provider_owner_address}") + + except web3.exceptions.ContractLogicError as e: + if 'execution reverted: task already terminated' in str(e): + p.status = "rewardable" + update_record(p, db.session) + logging.info(f"Task already terminated, status updated for {p.provider_owner_address}") + else: + logging.error(f"Error occurred when getting task contact: {str(e)}") + pass + except Exception as e: + logging.error(f"Error occurred when getting task contact: {str(e)}") + pass + + +if __name__ == "__main__": + update_task_contract() From 10b5941cd699b677604833fc808db98964a7ba25 Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 01:07:34 -0500 Subject: [PATCH 06/10] update payment --- backend/router/user.py | 2 +- backend/service/user_service.py | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/backend/router/user.py b/backend/router/user.py index 46d008b9..e38cca87 100644 --- a/backend/router/user.py +++ b/backend/router/user.py @@ -85,7 +85,7 @@ def check_provider_payment(user): response.status = constant.STATUS_FAILED return jsonify(response.to_dict()), 200 # payments = user_service.get_user_provider_payments(user, limit, offset) - payments = user_service.get_user_provider_payments(user) + payments = user_service.get_user_provider_payment_after_saturn(user) if payments is None: response.message = "No payments found" response.status = constant.SUCCESS diff --git a/backend/service/user_service.py b/backend/service/user_service.py index 344b4d28..b78c35ec 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -30,10 +30,11 @@ def get_user_provider_payments(user): return ProviderPayment.get_by_owner_address(user.public_address) -def get_user_provider_payment_after_saturn(order_id): - return ProviderPayment.get_by_owner_address(order_id).filter(ProviderPayment.created_at > 1705986000).all() - - +def get_user_provider_payment_after_saturn(user): + return ProviderPayment.query.filter( + ProviderPayment.provider_owner_address == user.public_address, + ProviderPayment.created_at > 1705986000 + ).order_by(ProviderPayment.provider_owner_address.desc()).all() def mark_payment_as_refunded(tx_hash, chain_id, user): payment = SpacePayment.get_payment_by_tx_hash(tx_hash, chain_id, user.id) if payment is None: From af19e8c9fac4a5f6aa13e30b488c766969fee7dd Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 01:18:03 -0500 Subject: [PATCH 07/10] update mark_claimed --- backend/model/provider_payment.py | 1 + 1 file changed, 1 insertion(+) diff --git a/backend/model/provider_payment.py b/backend/model/provider_payment.py index b12a9985..5988ae68 100644 --- a/backend/model/provider_payment.py +++ b/backend/model/provider_payment.py @@ -101,5 +101,6 @@ def get_by_job_and_wallet(wallet_address, job_id): def mark_claimed(payment, tx_hash=None): payment.transaction_hash = tx_hash payment.claimed = True + payment.status = "rewardSet" return update_record(payment, db.session) From 9dcd0401932d832062357314c2ca8618bc17979a Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 01:18:36 -0500 Subject: [PATCH 08/10] update mark_claimed --- backend/service/user_service.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/backend/service/user_service.py b/backend/service/user_service.py index b78c35ec..f026baea 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -33,7 +33,8 @@ def get_user_provider_payments(user): def get_user_provider_payment_after_saturn(user): return ProviderPayment.query.filter( ProviderPayment.provider_owner_address == user.public_address, - ProviderPayment.created_at > 1705986000 + ProviderPayment.created_at > 1705986000, + ProviderPayment.claimed == False ).order_by(ProviderPayment.provider_owner_address.desc()).all() def mark_payment_as_refunded(tx_hash, chain_id, user): payment = SpacePayment.get_payment_by_tx_hash(tx_hash, chain_id, user.id) From 639bd4a2c771631f0cd09e8d6b3fe4c770652ebf Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 01:18:52 -0500 Subject: [PATCH 09/10] update mark_claimed --- backend/service/user_service.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/backend/service/user_service.py b/backend/service/user_service.py index f026baea..b78c35ec 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -33,8 +33,7 @@ def get_user_provider_payments(user): def get_user_provider_payment_after_saturn(user): return ProviderPayment.query.filter( ProviderPayment.provider_owner_address == user.public_address, - ProviderPayment.created_at > 1705986000, - ProviderPayment.claimed == False + ProviderPayment.created_at > 1705986000 ).order_by(ProviderPayment.provider_owner_address.desc()).all() def mark_payment_as_refunded(tx_hash, chain_id, user): payment = SpacePayment.get_payment_by_tx_hash(tx_hash, chain_id, user.id) From 783188d027b878595ae087b874486cf43db84916 Mon Sep 17 00:00:00 2001 From: Pluto Zhang Date: Mon, 5 Feb 2024 01:19:34 -0500 Subject: [PATCH 10/10] reformat --- backend/service/user_service.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/backend/service/user_service.py b/backend/service/user_service.py index b78c35ec..63c69763 100644 --- a/backend/service/user_service.py +++ b/backend/service/user_service.py @@ -35,6 +35,8 @@ def get_user_provider_payment_after_saturn(user): ProviderPayment.provider_owner_address == user.public_address, ProviderPayment.created_at > 1705986000 ).order_by(ProviderPayment.provider_owner_address.desc()).all() + + def mark_payment_as_refunded(tx_hash, chain_id, user): payment = SpacePayment.get_payment_by_tx_hash(tx_hash, chain_id, user.id) if payment is None: