CryptoEscrow4U

Deploy Contract

Cryptoescrow4u Defi contracts, safely allow you transact crypto payments with strangers.If they do not deliver as agreed, the middleman @DaviewAk - who has no access to the funds uploaded to the contract by the buyer, can be called on to switch the contract state so the buyer can reclaim funds. The same feature is available to the seller, so both parties are protected. The contract source code is transparently displayed below . Deployed contracts must be verified against this source by the seller on the related blockchain.

Escrow contract is reusable after each transaction cycle. Buyer or Seller may deploy the contract and communicate contract details to the counterparty.

Counterparty, please copy the source in the text box below and verify the contract with the contract address communicated to you on the related Blockchain.

Base Fee : 3% or $10 whichever is larger. A Dispute resolution fee of 1% will apply if @DaviewAk has to intervene to resolve issues.

Make sure your Metamask is on the right chain where the Escrow contract was deployed or transactions will fail!

Issues? DM @Daviewak on Telegram.

When verifying the contract, select single file, 0.8.0 as Solidity compiler version, and MIT as license type.

Never transact with an unverified contract whose source code does not match the source code below!

Check carefully if there is a subtle difference between the Arbiter address on the deployed contract and the corresponding address listed here. Make sure to visit the Block Explorer of the chain where the contract was deployed and search for the contract address, confirm it was verified, and that the source is the same as the source in the text box below.

// SPDX-License-Identifier: MIT
            pragma solidity ^0.8.0;
            
            interface IERC20 {
                function transferFrom(
                    address sender,
                    address recipient,
                    uint256 amount
                ) external returns (bool);
            
                function transfer(address recipient, uint256 amount) external returns (bool);
            
                function approve(address spender, uint256 amount) external returns (bool);
            
                function allowance(address owner, address spender) external view returns (uint256);
            
                function balanceOf(address account) external view returns (uint256);
            }
            
            library SafeMath {
                function add(uint256 a, uint256 b) internal pure returns (uint256) {
                    uint256 c = a + b;
                    require(c >= a, "SafeMath: addition overflow");
                    return c;
                }
            
                function sub(uint256 a, uint256 b) internal pure returns (uint256) {
                    require(b <= a, "SafeMath: subtraction overflow");
                    uint256 c = a - b;
                    return c;
                }
            
                function mul(uint256 a, uint256 b) internal pure returns (uint256) {
                    if (a == 0) {
                        return 0;
                    }
                    uint256 c = a * b;
                    require(c / a == b, "SafeMath: multiplication overflow");
                    return c;
                }
            
                function div(uint256 a, uint256 b) internal pure returns (uint256) {
                    require(b > 0, "SafeMath: division by zero");
                    uint256 c = a / b;
                    return c;
                }
            }
            
            library SafeERC20 {
                using SafeMath for uint256;
            
                function safeTransferFrom(
                    IERC20 token,
                    address sender,
                    address recipient,
                    uint256 amount
                ) internal {
                    require(token.transferFrom(sender, recipient, amount), "SafeERC20: transferFrom failed");
                }
            
                function safeTransfer(
                    IERC20 token,
                    address to,
                    uint256 value
                ) internal {
                    require(token.transfer(to, value), "SafeERC20: transfer failed");
                }
            }
            
            contract EscrowContract {
                using SafeMath for uint256;
                using SafeERC20 for IERC20;
            
                enum ContractState {InProgress, BuyerApproved, ThirdPartyApprovedToBuyer, ThirdPartyApprovedToSeller, SellerRefundApproved}
            
                address public buyer;
                address public seller;
                address public thirdParty;
                address public constant baseFeeReceiver = 0x5eea518a7e44234b994A76f9970Cfc7F56Fa5E92;
                uint256 public constant feePercentage = 3;
                uint256 public disputefeePercentage;
                IERC20 public token;
                mapping(address => uint256) public balances;
                mapping(address => mapping(address => uint256)) allowed;
                ContractState public state;
            
                modifier onlyBuyer() {
                    require(msg.sender == buyer, "Only the buyer can call this function");
                    _;
                }
            
                modifier onlySeller() {
                    require(msg.sender == seller, "Only the seller can call this function");
                    _;
                }
            
                modifier onlyThirdParty() {
                    require(msg.sender == thirdParty, "Only the third party can call this function");
                    _;
                }
            
                modifier inProgressState() {
                    require(state == ContractState.InProgress, "Contract state is not InProgress");
                    _;
                }
            
                modifier buyerApprovedState() {
                    require(state == ContractState.BuyerApproved, "Contract state is not BuyerApproved");
                    _;
                }
            
                modifier thirdPartyApprovedToSellerState() {
                    require(state == ContractState.ThirdPartyApprovedToSeller, "Contract state is not ThirdPartyApprovedToSeller");
                    _;
                }
            
                modifier thirdPartyApprovedToBuyerState() {
                    require(state == ContractState.ThirdPartyApprovedToBuyer, "Contract state is not ThirdPartyApprovedToBuyer");
                    _;
                }
            
                modifier sellerRefundApprovedState() {
                    require(state == ContractState.SellerRefundApproved, "Contract state is not SellerRefundApproved");
                    _;
                }
            
                event TokensDeposited(address indexed depositor, uint256 amount);
                event BuyerApproved();
                event SellerRefundApproved();
                event ThirdPartyApprovedToSeller();
                event ThirdPartyApprovedToBuyer();
                event TokensClaimed(address indexed recipient, uint256 amount);
            
                constructor(
                    address _buyer,
                    address _seller,
                    address _token,
                    address _thirdParty,
                    uint256 _disputefeePercentage
                ) {
                    require(_buyer != address(0), "Invalid buyer address");
                    require(_seller != address(0), "Invalid seller address");
                    require(_token != address(0), "Invalid token address");
                    require(_thirdParty != address(0), "Invalid thirdParty address");
            
                    buyer = _buyer;
                    seller = _seller;
                    thirdParty = _thirdParty;
                    disputefeePercentage = _disputefeePercentage;
                    token = IERC20(_token);
                    state = ContractState.InProgress;
                }
            
                function depositTokens(uint256 amount) external onlyBuyer inProgressState {
                    require(amount > 0, "Deposit amount must be greater than zero");
                    uint256 allowance = token.allowance(msg.sender, address(this));
                    require(allowance >= amount, "Do not have enough allowance");
                    uint256 prevBalance = balances[address(this)];
                    token.safeTransferFrom(msg.sender, address(this), amount);
                    balances[address(this)] = balances[address(this)].add(amount);
                    require(balances[address(this)].sub(amount) == prevBalance, "Tx Failed");
                    emit TokensDeposited(msg.sender, amount);
                }
            
                function approveByBuyer() external onlyBuyer inProgressState {
                    state = ContractState.BuyerApproved;
                    emit BuyerApproved();
                }
            
                function approveByThirdPartyToSeller() external onlyThirdParty {
                    state = ContractState.ThirdPartyApprovedToSeller;
                    emit ThirdPartyApprovedToSeller();
                }
            
                function approveByThirdPartyToBuyer() external onlyThirdParty {
                    state = ContractState.ThirdPartyApprovedToBuyer;
                    emit ThirdPartyApprovedToBuyer();
                }
            
                function sellerRefundToBuyer() external onlySeller {
                    state = ContractState.SellerRefundApproved;
                    emit SellerRefundApproved();
                }
            
                function claimTokensInDispute() external onlyBuyer thirdPartyApprovedToBuyerState {
                    uint256 depositAmount = token.balanceOf(address(this));
                    uint256 availableAmount = depositAmount.mul(100 - (disputefeePercentage.add(feePercentage))).div(100);
                    uint256 baseFeeAmount = depositAmount.mul(feePercentage).div(100);
                    uint256 disputeFeeAmount = depositAmount.mul(disputefeePercentage).div(100);
                    uint256 totalAmountSent = baseFeeAmount.add(disputeFeeAmount).add(availableAmount);
                    require(depositAmount > 0, "No tokens available to claim");
                    state = ContractState.InProgress;
                    token.safeTransfer(baseFeeReceiver, baseFeeAmount);
                    token.safeTransfer(thirdParty, disputeFeeAmount);
                    token.safeTransfer(buyer, availableAmount);
                    balances[address(this)] = balances[address(this)].sub(totalAmountSent);
                    require(balances[address(this)].add(totalAmountSent) == depositAmount, "Tx Failed"); /// check if successful
                    emit TokensClaimed(buyer, availableAmount);
                }
            
                function claimTokensByBuyer() external onlyBuyer sellerRefundApprovedState {
                    uint256 depositAmount = token.balanceOf(address(this));
                    uint256 availableAmount = depositAmount.mul(100 - (disputefeePercentage.add(feePercentage))).div(100);
                    uint256 baseFeeAmount = depositAmount.mul(feePercentage).div(100);
                    uint256 disputeFeeAmount = depositAmount.mul(disputefeePercentage).div(100);
                    uint256 totalAmountSent = baseFeeAmount.add(disputeFeeAmount).add(availableAmount);
                    require(depositAmount > 0, "No tokens available to claim");
                    state = ContractState.InProgress;
                    token.safeTransfer(baseFeeReceiver, baseFeeAmount);
                    token.safeTransfer(thirdParty, disputeFeeAmount);
                    token.safeTransfer(buyer, availableAmount);
                    balances[address(this)] = balances[address(this)].sub(totalAmountSent);
                    require(balances[address(this)].add(totalAmountSent) == depositAmount, "Tx Failed"); /// check if successful
                    emit TokensClaimed(buyer, availableAmount);
                }
            
                function claimTokensBySellerInDispute() external onlySeller thirdPartyApprovedToSellerState {
                    uint256 depositAmount = token.balanceOf(address(this));
                    uint256 availableAmount = depositAmount.mul(100 - (disputefeePercentage.add(feePercentage))).div(100);
                    uint256 baseFeeAmount = depositAmount.mul(feePercentage).div(100);
                    uint256 disputeFeeAmount = depositAmount.mul(disputefeePercentage).div(100);
                    uint256 totalAmountSent = baseFeeAmount.add(disputeFeeAmount).add(availableAmount);
                    require(depositAmount > 0, "No tokens available to claim");
                    state = ContractState.InProgress;
                    token.safeTransfer(baseFeeReceiver, baseFeeAmount);
                    token.safeTransfer(thirdParty, disputeFeeAmount);
                    token.safeTransfer(seller, availableAmount);
                    balances[address(this)] = balances[address(this)].sub(totalAmountSent);
                    require(balances[address(this)].add(totalAmountSent) == depositAmount, "Tx Failed"); /// check if successful
                    emit TokensClaimed(seller, availableAmount);
                }
            
                function claimTokensBySeller() external onlySeller buyerApprovedState {
                    uint256 depositAmount = token.balanceOf(address(this));
                    uint256 availableAmount = depositAmount.mul(100 - (disputefeePercentage.add(feePercentage))).div(100);
                    uint256 baseFeeAmount = depositAmount.mul(feePercentage).div(100);
                    uint256 disputeFeeAmount = depositAmount.mul(disputefeePercentage).div(100);
                    uint256 totalAmountSent = baseFeeAmount.add(disputeFeeAmount).add(availableAmount);
                    require(depositAmount > 0, "No tokens available to claim");
                    state = ContractState.InProgress;
                    token.safeTransfer(baseFeeReceiver, baseFeeAmount);
                    token.safeTransfer(thirdParty, disputeFeeAmount);
                    token.safeTransfer(seller, availableAmount);
                    balances[address(this)] = balances[address(this)].sub(totalAmountSent);
                    require(balances[address(this)].add(totalAmountSent) == depositAmount, "Tx Failed"); /// check if successful
                    emit TokensClaimed(seller, availableAmount);
                }
            
                function getContractBalance() external view returns (uint256) {
                    return balances[address(this)];
                }
            }

Middleman Arbiter Telegram:
Telegram Channel:
Address:
Fee in %:
Select Blockchain
Select Stablecoin:
Buyer Address:
Seller Address:

Connected wallet address:

CryptoEscrow4u

Deploy Contract

Get in Touch

Telegram: