refactor(contracts): remove deprecated AIPowerRental contract in favor of bounty system
- Delete AIPowerRental.sol (566 lines) - replaced by AgentBounty.sol - Remove rental agreement system with provider/consumer model - Remove performance metrics and SLA tracking - Remove dispute resolution mechanism - Remove ZK-proof verification for performance - Remove provider/consumer authorization system - Bounty system provides superior developer incentive structure
This commit is contained in:
oib
696
contracts/contracts/AITBCPaymentProcessor.sol
Normal file
696
contracts/contracts/AITBCPaymentProcessor.sol
Normal file
@@ -0,0 +1,696 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
pragma solidity ^0.8.19;
|
||||
|
||||
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
|
||||
import "@openzeppelin/contracts/access/Ownable.sol";
|
||||
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
|
||||
import "@openzeppelin/contracts/security/Pausable.sol";
|
||||
import "./AIPowerRental.sol";
|
||||
|
||||
/**
|
||||
* @title AITBC Payment Processor
|
||||
* @dev Advanced payment processing contract with escrow, automated releases, and dispute resolution
|
||||
* @notice Handles AITBC token payments for AI power rental services
|
||||
*/
|
||||
contract AITBCPaymentProcessor is Ownable, ReentrancyGuard, Pausable {
|
||||
|
||||
// State variables
|
||||
IERC20 public aitbcToken;
|
||||
AIPowerRental public aiPowerRental;
|
||||
|
||||
uint256 public paymentCounter;
|
||||
uint256 public platformFeePercentage = 250; // 2.5% in basis points
|
||||
uint256 public disputeResolutionFee = 100; // 1% in basis points
|
||||
uint256 public minPaymentAmount = 1e15; // 0.001 AITBC minimum
|
||||
uint256 public maxPaymentAmount = 1e22; // 10,000 AITBC maximum
|
||||
|
||||
// Structs
|
||||
struct Payment {
|
||||
uint256 paymentId;
|
||||
address from;
|
||||
address to;
|
||||
uint256 amount;
|
||||
uint256 platformFee;
|
||||
uint256 disputeFee;
|
||||
PaymentStatus status;
|
||||
uint256 releaseTime;
|
||||
uint256 createdTime;
|
||||
uint256 confirmedTime;
|
||||
bytes32 agreementId;
|
||||
string paymentPurpose;
|
||||
ReleaseCondition releaseCondition;
|
||||
bytes32 conditionHash;
|
||||
}
|
||||
|
||||
struct EscrowAccount {
|
||||
uint256 escrowId;
|
||||
address depositor;
|
||||
address beneficiary;
|
||||
uint256 amount;
|
||||
uint256 releaseTime;
|
||||
bool isReleased;
|
||||
bool isRefunded;
|
||||
bytes32 releaseCondition;
|
||||
uint256 createdTime;
|
||||
EscrowType escrowType;
|
||||
}
|
||||
|
||||
struct ScheduledPayment {
|
||||
uint256 scheduleId;
|
||||
uint256 paymentId;
|
||||
uint256 nextReleaseTime;
|
||||
uint256 releaseInterval;
|
||||
uint256 totalReleases;
|
||||
uint256 releasedCount;
|
||||
bool isActive;
|
||||
}
|
||||
|
||||
// Enums
|
||||
enum PaymentStatus {
|
||||
Created,
|
||||
Confirmed,
|
||||
HeldInEscrow,
|
||||
Released,
|
||||
Refunded,
|
||||
Disputed,
|
||||
Cancelled
|
||||
}
|
||||
|
||||
enum EscrowType {
|
||||
Standard,
|
||||
PerformanceBased,
|
||||
TimeBased,
|
||||
Conditional
|
||||
}
|
||||
|
||||
enum ReleaseCondition {
|
||||
Immediate,
|
||||
Manual,
|
||||
Performance,
|
||||
TimeBased,
|
||||
DisputeResolution
|
||||
}
|
||||
|
||||
// Mappings
|
||||
mapping(uint256 => Payment) public payments;
|
||||
mapping(uint256 => EscrowAccount) public escrowAccounts;
|
||||
mapping(uint256 => ScheduledPayment) public scheduledPayments;
|
||||
mapping(address => uint256[]) public senderPayments;
|
||||
mapping(address => uint256[]) public recipientPayments;
|
||||
mapping(bytes32 => uint256) public agreementPayments;
|
||||
mapping(address => uint256) public userEscrowBalance;
|
||||
mapping(address => bool) public authorizedPayees;
|
||||
mapping(address => bool) public authorizedPayers;
|
||||
|
||||
// Events
|
||||
event PaymentCreated(
|
||||
uint256 indexed paymentId,
|
||||
address indexed from,
|
||||
address indexed to,
|
||||
uint256 amount,
|
||||
bytes32 agreementId,
|
||||
string paymentPurpose
|
||||
);
|
||||
|
||||
event PaymentConfirmed(
|
||||
uint256 indexed paymentId,
|
||||
uint256 confirmedTime,
|
||||
bytes32 transactionHash
|
||||
);
|
||||
|
||||
event PaymentReleased(
|
||||
uint256 indexed paymentId,
|
||||
address indexed to,
|
||||
uint256 amount,
|
||||
uint256 platformFee
|
||||
);
|
||||
|
||||
event PaymentRefunded(
|
||||
uint256 indexed paymentId,
|
||||
address indexed to,
|
||||
uint256 amount,
|
||||
string reason
|
||||
);
|
||||
|
||||
event EscrowCreated(
|
||||
uint256 indexed escrowId,
|
||||
address indexed depositor,
|
||||
address indexed beneficiary,
|
||||
uint256 amount,
|
||||
EscrowType escrowType
|
||||
);
|
||||
|
||||
event EscrowReleased(
|
||||
uint256 indexed escrowId,
|
||||
uint256 amount,
|
||||
bytes32 conditionHash
|
||||
);
|
||||
|
||||
event EscrowRefunded(
|
||||
uint256 indexed escrowId,
|
||||
address indexed depositor,
|
||||
uint256 amount,
|
||||
string reason
|
||||
);
|
||||
|
||||
event ScheduledPaymentCreated(
|
||||
uint256 indexed scheduleId,
|
||||
uint256 indexed paymentId,
|
||||
uint256 nextReleaseTime,
|
||||
uint256 releaseInterval
|
||||
);
|
||||
|
||||
event ScheduledPaymentReleased(
|
||||
uint256 indexed scheduleId,
|
||||
uint256 indexed paymentId,
|
||||
uint256 releaseCount
|
||||
);
|
||||
|
||||
event DisputeInitiated(
|
||||
uint256 indexed paymentId,
|
||||
address indexed initiator,
|
||||
string reason
|
||||
);
|
||||
|
||||
event DisputeResolved(
|
||||
uint256 indexed paymentId,
|
||||
uint256 resolutionAmount,
|
||||
bool resolvedInFavorOfPayer
|
||||
);
|
||||
|
||||
event PlatformFeeCollected(
|
||||
uint256 indexed paymentId,
|
||||
uint256 feeAmount,
|
||||
address indexed collector
|
||||
);
|
||||
|
||||
// Modifiers
|
||||
modifier onlyAuthorizedPayer() {
|
||||
require(authorizedPayers[msg.sender], "Not authorized payer");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier onlyAuthorizedPayee() {
|
||||
require(authorizedPayees[msg.sender], "Not authorized payee");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier paymentExists(uint256 _paymentId) {
|
||||
require(_paymentId < paymentCounter, "Payment does not exist");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier validStatus(uint256 _paymentId, PaymentStatus _requiredStatus) {
|
||||
require(payments[_paymentId].status == _requiredStatus, "Invalid payment status");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier sufficientBalance(address _user, uint256 _amount) {
|
||||
require(aitbcToken.balanceOf(_user) >= _amount, "Insufficient balance");
|
||||
_;
|
||||
}
|
||||
|
||||
modifier sufficientAllowance(address _user, uint256 _amount) {
|
||||
require(aitbcToken.allowance(_user, address(this)) >= _amount, "Insufficient allowance");
|
||||
_;
|
||||
}
|
||||
|
||||
// Constructor
|
||||
constructor(address _aitbcToken, address _aiPowerRental) {
|
||||
aitbcToken = IERC20(_aitbcToken);
|
||||
aiPowerRental = AIPowerRental(_aiPowerRental);
|
||||
paymentCounter = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Creates a new payment
|
||||
* @param _to Recipient address
|
||||
* @param _amount Payment amount
|
||||
* @param _agreementId Associated agreement ID
|
||||
* @param _paymentPurpose Purpose of the payment
|
||||
* @param _releaseCondition Release condition
|
||||
*/
|
||||
function createPayment(
|
||||
address _to,
|
||||
uint256 _amount,
|
||||
bytes32 _agreementId,
|
||||
string memory _paymentPurpose,
|
||||
ReleaseCondition _releaseCondition
|
||||
) external onlyAuthorizedPayer sufficientBalance(msg.sender, _amount) sufficientAllowance(msg.sender, _amount) nonReentrant whenNotPaused returns (uint256) {
|
||||
require(_amount >= minPaymentAmount, "Amount below minimum");
|
||||
require(_amount <= maxPaymentAmount, "Amount above maximum");
|
||||
require(_to != address(0), "Invalid recipient");
|
||||
require(authorizedPayees[_to], "Recipient not authorized");
|
||||
|
||||
uint256 paymentId = paymentCounter++;
|
||||
uint256 platformFee = (_amount * platformFeePercentage) / 10000;
|
||||
uint256 disputeFee = (_amount * disputeResolutionFee) / 10000;
|
||||
uint256 totalAmount = _amount + platformFee + disputeFee;
|
||||
|
||||
payments[paymentId] = Payment({
|
||||
paymentId: paymentId,
|
||||
from: msg.sender,
|
||||
to: _to,
|
||||
amount: _amount,
|
||||
platformFee: platformFee,
|
||||
disputeFee: disputeFee,
|
||||
status: PaymentStatus.Created,
|
||||
releaseTime: 0,
|
||||
createdTime: block.timestamp,
|
||||
confirmedTime: 0,
|
||||
agreementId: _agreementId,
|
||||
paymentPurpose: _paymentPurpose,
|
||||
releaseCondition: _releaseCondition,
|
||||
conditionHash: bytes32(0)
|
||||
});
|
||||
|
||||
senderPayments[msg.sender].push(paymentId);
|
||||
recipientPayments[_to].push(paymentId);
|
||||
|
||||
if (_agreementId != bytes32(0)) {
|
||||
agreementPayments[_agreementId] = paymentId;
|
||||
}
|
||||
|
||||
// Transfer tokens to contract
|
||||
require(
|
||||
aitbcToken.transferFrom(msg.sender, address(this), totalAmount),
|
||||
"Payment transfer failed"
|
||||
);
|
||||
|
||||
emit PaymentCreated(paymentId, msg.sender, _to, _amount, _agreementId, _paymentPurpose);
|
||||
|
||||
return paymentId;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Confirms a payment with transaction hash
|
||||
* @param _paymentId ID of the payment
|
||||
* @param _transactionHash Blockchain transaction hash
|
||||
*/
|
||||
function confirmPayment(uint256 _paymentId, bytes32 _transactionHash)
|
||||
external
|
||||
paymentExists(_paymentId)
|
||||
validStatus(_paymentId, PaymentStatus.Created)
|
||||
nonReentrant
|
||||
{
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
require(msg.sender == payment.from, "Only payer can confirm");
|
||||
|
||||
payment.status = PaymentStatus.Confirmed;
|
||||
payment.confirmedTime = block.timestamp;
|
||||
payment.conditionHash = _transactionHash;
|
||||
|
||||
// Handle immediate release
|
||||
if (payment.releaseCondition == ReleaseCondition.Immediate) {
|
||||
_releasePayment(_paymentId);
|
||||
} else if (payment.releaseCondition == ReleaseCondition.TimeBased) {
|
||||
payment.status = PaymentStatus.HeldInEscrow;
|
||||
payment.releaseTime = block.timestamp + 1 hours; // Default 1 hour hold
|
||||
} else {
|
||||
payment.status = PaymentStatus.HeldInEscrow;
|
||||
}
|
||||
|
||||
emit PaymentConfirmed(_paymentId, block.timestamp, _transactionHash);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Releases a payment to the recipient
|
||||
* @param _paymentId ID of the payment
|
||||
*/
|
||||
function releasePayment(uint256 _paymentId)
|
||||
external
|
||||
paymentExists(_paymentId)
|
||||
nonReentrant
|
||||
{
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
require(
|
||||
payment.status == PaymentStatus.Confirmed ||
|
||||
payment.status == PaymentStatus.HeldInEscrow,
|
||||
"Payment not ready for release"
|
||||
);
|
||||
|
||||
if (payment.releaseCondition == ReleaseCondition.Manual) {
|
||||
require(msg.sender == payment.from, "Only payer can release manually");
|
||||
} else if (payment.releaseCondition == ReleaseCondition.TimeBased) {
|
||||
require(block.timestamp >= payment.releaseTime, "Release time not reached");
|
||||
}
|
||||
|
||||
_releasePayment(_paymentId);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Creates an escrow account
|
||||
* @param _beneficiary Beneficiary address
|
||||
* @param _amount Amount to lock in escrow
|
||||
* @param _releaseTime Release time (0 for no time limit)
|
||||
* @param _escrowType Type of escrow
|
||||
* @param _releaseCondition Release condition hash
|
||||
*/
|
||||
function createEscrow(
|
||||
address _beneficiary,
|
||||
uint256 _amount,
|
||||
uint256 _releaseTime,
|
||||
EscrowType _escrowType,
|
||||
bytes32 _releaseCondition
|
||||
) external onlyAuthorizedPayer sufficientBalance(msg.sender, _amount) sufficientAllowance(msg.sender, _amount) nonReentrant whenNotPaused returns (uint256) {
|
||||
require(_beneficiary != address(0), "Invalid beneficiary");
|
||||
require(_amount >= minPaymentAmount, "Amount below minimum");
|
||||
|
||||
uint256 escrowId = paymentCounter++;
|
||||
|
||||
escrowAccounts[escrowId] = EscrowAccount({
|
||||
escrowId: escrowId,
|
||||
depositor: msg.sender,
|
||||
beneficiary: _beneficiary,
|
||||
amount: _amount,
|
||||
releaseTime: _releaseTime,
|
||||
isReleased: false,
|
||||
isRefunded: false,
|
||||
releaseCondition: _releaseCondition,
|
||||
createdTime: block.timestamp,
|
||||
escrowType: _escrowType
|
||||
});
|
||||
|
||||
// Transfer tokens to contract
|
||||
require(
|
||||
aitbcToken.transferFrom(msg.sender, address(this), _amount),
|
||||
"Escrow transfer failed"
|
||||
);
|
||||
|
||||
userEscrowBalance[msg.sender] += _amount;
|
||||
|
||||
emit EscrowCreated(escrowId, msg.sender, _beneficiary, _amount, _escrowType);
|
||||
|
||||
return escrowId;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Releases escrow to beneficiary
|
||||
* @param _escrowId ID of the escrow account
|
||||
*/
|
||||
function releaseEscrow(uint256 _escrowId)
|
||||
external
|
||||
nonReentrant
|
||||
{
|
||||
EscrowAccount storage escrow = escrowAccounts[_escrowId];
|
||||
|
||||
require(!escrow.isReleased, "Escrow already released");
|
||||
require(!escrow.isRefunded, "Escrow already refunded");
|
||||
require(
|
||||
escrow.releaseTime == 0 || block.timestamp >= escrow.releaseTime,
|
||||
"Release time not reached"
|
||||
);
|
||||
|
||||
escrow.isReleased = true;
|
||||
userEscrowBalance[escrow.depositor] -= escrow.amount;
|
||||
|
||||
require(
|
||||
aitbcToken.transfer(escrow.beneficiary, escrow.amount),
|
||||
"Escrow release failed"
|
||||
);
|
||||
|
||||
emit EscrowReleased(_escrowId, escrow.amount, escrow.releaseCondition);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Refunds escrow to depositor
|
||||
* @param _escrowId ID of the escrow account
|
||||
* @param _reason Reason for refund
|
||||
*/
|
||||
function refundEscrow(uint256 _escrowId, string memory _reason)
|
||||
external
|
||||
nonReentrant
|
||||
{
|
||||
EscrowAccount storage escrow = escrowAccounts[_escrowId];
|
||||
|
||||
require(!escrow.isReleased, "Escrow already released");
|
||||
require(!escrow.isRefunded, "Escrow already refunded");
|
||||
require(
|
||||
msg.sender == escrow.depositor || msg.sender == owner(),
|
||||
"Only depositor or owner can refund"
|
||||
);
|
||||
|
||||
escrow.isRefunded = true;
|
||||
userEscrowBalance[escrow.depositor] -= escrow.amount;
|
||||
|
||||
require(
|
||||
aitbcToken.transfer(escrow.depositor, escrow.amount),
|
||||
"Escrow refund failed"
|
||||
);
|
||||
|
||||
emit EscrowRefunded(_escrowId, escrow.depositor, escrow.amount, _reason);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Initiates a dispute for a payment
|
||||
* @param _paymentId ID of the payment
|
||||
* @param _reason Reason for dispute
|
||||
*/
|
||||
function initiateDispute(uint256 _paymentId, string memory _reason)
|
||||
external
|
||||
paymentExists(_paymentId)
|
||||
nonReentrant
|
||||
{
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
require(
|
||||
payment.status == PaymentStatus.Confirmed ||
|
||||
payment.status == PaymentStatus.HeldInEscrow,
|
||||
"Cannot dispute this payment"
|
||||
);
|
||||
|
||||
require(
|
||||
msg.sender == payment.from || msg.sender == payment.to,
|
||||
"Only payment participants can dispute"
|
||||
);
|
||||
|
||||
payment.status = PaymentStatus.Disputed;
|
||||
|
||||
emit DisputeInitiated(_paymentId, msg.sender, _reason);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Resolves a dispute
|
||||
* @param _paymentId ID of the disputed payment
|
||||
* @param _resolutionAmount Amount to award to the winner
|
||||
* @param _resolveInFavorOfPayer True if resolving in favor of payer
|
||||
*/
|
||||
function resolveDispute(
|
||||
uint256 _paymentId,
|
||||
uint256 _resolutionAmount,
|
||||
bool _resolveInFavorOfPayer
|
||||
) external onlyOwner paymentExists(_paymentId) nonReentrant {
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
require(payment.status == PaymentStatus.Disputed, "Payment not disputed");
|
||||
require(_resolutionAmount <= payment.amount, "Resolution amount too high");
|
||||
|
||||
address winner = _resolveInFavorOfPayer ? payment.from : payment.to;
|
||||
address loser = _resolveInFavorOfPayer ? payment.to : payment.from;
|
||||
|
||||
// Calculate refund for loser
|
||||
uint256 refundAmount = payment.amount - _resolutionAmount;
|
||||
|
||||
// Transfer resolution amount to winner
|
||||
if (_resolutionAmount > 0) {
|
||||
require(
|
||||
aitbcToken.transfer(winner, _resolutionAmount),
|
||||
"Resolution payment failed"
|
||||
);
|
||||
}
|
||||
|
||||
// Refund remaining amount to loser
|
||||
if (refundAmount > 0) {
|
||||
require(
|
||||
aitbcToken.transfer(loser, refundAmount),
|
||||
"Refund payment failed"
|
||||
);
|
||||
}
|
||||
|
||||
payment.status = PaymentStatus.Released;
|
||||
|
||||
emit DisputeResolved(_paymentId, _resolutionAmount, _resolveInFavorOfPayer);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Claims platform fees
|
||||
* @param _paymentId ID of the payment
|
||||
*/
|
||||
function claimPlatformFee(uint256 _paymentId)
|
||||
external
|
||||
onlyOwner
|
||||
paymentExists(_paymentId)
|
||||
nonReentrant
|
||||
{
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
require(payment.status == PaymentStatus.Released, "Payment not released");
|
||||
require(payment.platformFee > 0, "No platform fee to claim");
|
||||
|
||||
uint256 feeAmount = payment.platformFee;
|
||||
payment.platformFee = 0;
|
||||
|
||||
require(
|
||||
aitbcToken.transfer(owner(), feeAmount),
|
||||
"Platform fee transfer failed"
|
||||
);
|
||||
|
||||
emit PlatformFeeCollected(_paymentId, feeAmount, owner());
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Authorizes a payee
|
||||
* @param _payee Address to authorize
|
||||
*/
|
||||
function authorizePayee(address _payee) external onlyOwner {
|
||||
authorizedPayees[_payee] = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Revokes payee authorization
|
||||
* @param _payee Address to revoke
|
||||
*/
|
||||
function revokePayee(address _payee) external onlyOwner {
|
||||
authorizedPayees[_payee] = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Authorizes a payer
|
||||
* @param _payer Address to authorize
|
||||
*/
|
||||
function authorizePayer(address _payer) external onlyOwner {
|
||||
authorizedPayers[_payer] = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Revokes payer authorization
|
||||
* @param _payer Address to revoke
|
||||
*/
|
||||
function revokePayer(address _payer) external onlyOwner {
|
||||
authorizedPayers[_payer] = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Updates platform fee percentage
|
||||
* @param _newFee New fee percentage in basis points
|
||||
*/
|
||||
function updatePlatformFee(uint256 _newFee) external onlyOwner {
|
||||
require(_newFee <= 1000, "Fee too high"); // Max 10%
|
||||
platformFeePercentage = _newFee;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Emergency pause function
|
||||
*/
|
||||
function pause() external onlyOwner {
|
||||
_pause();
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Unpause function
|
||||
*/
|
||||
function unpause() external onlyOwner {
|
||||
_unpause();
|
||||
}
|
||||
|
||||
// Internal functions
|
||||
|
||||
function _releasePayment(uint256 _paymentId) internal {
|
||||
Payment storage payment = payments[_paymentId];
|
||||
|
||||
payment.status = PaymentStatus.Released;
|
||||
|
||||
// Transfer amount to recipient
|
||||
require(
|
||||
aitbcToken.transfer(payment.to, payment.amount),
|
||||
"Payment transfer failed"
|
||||
);
|
||||
|
||||
// Transfer platform fee to owner
|
||||
if (payment.platformFee > 0) {
|
||||
require(
|
||||
aitbcToken.transfer(owner(), payment.platformFee),
|
||||
"Platform fee transfer failed"
|
||||
);
|
||||
}
|
||||
|
||||
emit PaymentReleased(_paymentId, payment.to, payment.amount, payment.platformFee);
|
||||
}
|
||||
|
||||
// View functions
|
||||
|
||||
/**
|
||||
* @dev Gets payment details
|
||||
* @param _paymentId ID of the payment
|
||||
*/
|
||||
function getPayment(uint256 _paymentId)
|
||||
external
|
||||
view
|
||||
paymentExists(_paymentId)
|
||||
returns (Payment memory)
|
||||
{
|
||||
return payments[_paymentId];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets escrow account details
|
||||
* @param _escrowId ID of the escrow account
|
||||
*/
|
||||
function getEscrowAccount(uint256 _escrowId)
|
||||
external
|
||||
view
|
||||
returns (EscrowAccount memory)
|
||||
{
|
||||
return escrowAccounts[_escrowId];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all payments for a sender
|
||||
* @param _sender Address of the sender
|
||||
*/
|
||||
function getSenderPayments(address _sender)
|
||||
external
|
||||
view
|
||||
returns (uint256[] memory)
|
||||
{
|
||||
return senderPayments[_sender];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets all payments for a recipient
|
||||
* @param _recipient Address of the recipient
|
||||
*/
|
||||
function getRecipientPayments(address _recipient)
|
||||
external
|
||||
view
|
||||
returns (uint256[] memory)
|
||||
{
|
||||
return recipientPayments[_recipient];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets payment associated with an agreement
|
||||
* @param _agreementId ID of the agreement
|
||||
*/
|
||||
function getAgreementPayment(bytes32 _agreementId)
|
||||
external
|
||||
view
|
||||
returns (uint256)
|
||||
{
|
||||
return agreementPayments[_agreementId];
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Gets user's escrow balance
|
||||
* @param _user Address of the user
|
||||
*/
|
||||
function getUserEscrowBalance(address _user)
|
||||
external
|
||||
view
|
||||
returns (uint256)
|
||||
{
|
||||
return userEscrowBalance[_user];
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user