XcrowedGiveaways.com

Deploy Winner Giver List Offer Listings

Deploy Giveaway Contract

Show good faith by creating an escrow between your address and a fresh Eth address for which you hold the private key, and select "One way escrow", which means funds can not be retrieved once deposited in the escrow, except by the winner. Once you fund that escrow and release the funds on the Giver page, only whoever you give the privatekeys of the receiver address can claim the excrow.Use a picker website like twitterpicker.com to pick giveaway winner.

Base fee: 1%

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

Issues? Dm @Timbuctuu on Telegram or @Xcrowedgiveaway on Twitter

Copy and use the contract source in the text box below to verify the contract on the chain deployed to.

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

// 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 = 0x05e1fd34E3E7CB47f313bf477Fcf68AA97176258;
             uint256 public constant feePercentage = 1;
             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)];
             }
         }

Select:
Address:
Additional Fee in %:
Select Blockchain
Select Stablecoin:
Giver Address:
Winner Address:

Connected wallet address:

Costs around $0.006 depending on network conditions to create the escrow contract (make sure to edit your Gas limit when deploying the contract to 2999999 (2.999999 M) or the transaction may fail) and $0.000005 for other transactions. Its stablecoin native currency xDai is available from https://buyxdai.com DEX or from https://www.ascendex.com CEX. This is the cheapest option