土豪发红包合约

contracts/business_template/redpacket/IERC20.sol

@@ -0,0 +1,20 @@
+pragma solidity^0.6.10;
+
+//定义接口
+interface IERC20 {
+
+   function name() external view returns (string memory);
+   function symbol() external view returns (string memory);
+   function totalSupply() external view returns (uint256);
+   function balanceOf(address _owner) external view returns (uint256 balance);
+   function transfer(address _to, uint256 _value) external returns (bool success);
+   function approve(address _spender, uint256 _value) external returns (bool success);
+   function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
+   function allowance(address _owner, address _spender) external view returns (uint256 remaining);
+
+
+
+   event Transfer(address indexed _from, address indexed _to, uint256 _value);
+   event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+
+}

contracts/business_template/redpacket/SafeMath.sol

@@ -0,0 +1,65 @@
+pragma solidity ^0.6.10;
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that revert on error
+ */
+library SafeMath {
+
+  /**
+  * @dev Multiplies two numbers, reverts on overflow.
+  */
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+    // benefit is lost if 'b' is also tested.
+    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
+    if (a == 0) {
+      return 0;
+    }
+
+    uint256 c = a * b;
+    require(c / a == b);
+
+    return c;
+  }
+
+  /**
+  * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
+  */
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b > 0); // Solidity only automatically asserts when dividing by 0
+    uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+
+    return c;
+  }
+
+  /**
+  * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
+  */
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b <= a);
+    uint256 c = a - b;
+
+    return c;
+  }
+
+  /**
+  * @dev Adds two numbers, reverts on overflow.
+  */
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    require(c >= a);
+
+    return c;
+  }
+
+  /**
+  * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
+  * reverts when dividing by zero.
+  */
+  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b != 0);
+    return a % b;
+  }
+}

contracts/business_template/redpacket/mypoints.sol

@@ -0,0 +1,94 @@
+pragma solidity^0.6.10;
+
+import "./IERC20.sol";
+import "./SafeMath.sol";
+
+
+//定义接口
+contract mypoints is  IERC20 {
+    using SafeMath for uint256;
+    //定义name
+    string pointName;
+    string pointSymbol;
+    uint256 pointTotalSupply;
+    address owner;
+    //user's balance 
+    mapping(address=>uint256) balances;
+    // A->B = 100 A->C 200 
+    mapping(address=>mapping(address=>uint256)) allows;
+
+    constructor(string memory n, string memory s) public {
+        pointName = n;
+        pointSymbol = s;
+        owner = msg.sender;
+    }
+
+    function mint(address _to, uint256 _value) external returns (bool success) {
+        require(_value > 0, "_value must > 0");
+        require(address(0) != _to, "to must a valid address");
+        require(msg.sender == owner, "only owner can do");
+
+
+        balances[_to] = balances[_to].add(_value);
+        pointTotalSupply = pointTotalSupply.add(_value);
+        emit Transfer(address(0), _to, _value);
+        success = true;
+    }
+
+   function name() override external view returns (string memory) {
+       return pointName;
+   }
+   function symbol() override external view returns (string memory) {
+       return pointSymbol;
+   }
+   function totalSupply() override external view returns (uint256) {
+       return pointTotalSupply;
+   }
+   function balanceOf(address _owner) override external view returns (uint256 balance) {
+       return balances[_owner];
+   }
+   function transfer(address _to, uint256 _value) override external returns (bool success) {
+       require(_value > 0, "_value must > 0");
+       require(address(0) != _to, "to must a valid address");
+       require(balances[msg.sender] >= _value, "user's balance must enough");
+
+       //balances[msg.sender] -= _value;
+       balances[msg.sender] = balances[msg.sender].sub(_value);
+       //balances[_to] += _value;
+       balances[_to] = balances[_to].add(_value);
+
+       emit Transfer(msg.sender, _to, _value);
+       return true;
+   }
+   function approve(address _spender, uint256 _value) override external returns (bool success) {
+       success = false;
+       require(_value > 0, "_value must > 0");
+       require(address(0) != _spender, "_spender must a valid address");
+       require(balances[msg.sender] >= _value, "user's balance must enough");
+
+       allows[msg.sender][_spender] = _value;
+
+       emit Approval(msg.sender, _spender, _value);
+       success = true;
+       return true;
+   }
+   function transferFrom(address _from, address _to, uint256 _value) override external returns (bool success) {
+       require(_value > 0, "_value must > 0");
+       require(address(0) != _to, "to must a valid address");
+       require(balances[_from] >= _value, "user's balance must enough");
+
+       //balances[_from]  -= _value;
+       balances[_from] = balances[_from].sub(_value);
+       //balances[_to] += _value;
+       balances[_to] = balances[_to].add(_value);
+       //allows[_from][msg.sender] -= _value;
+       allows[_from][msg.sender] = allows[_from][msg.sender].sub(_value);
+
+       success = true;
+       emit Transfer(_from, _to, _value);
+   }
+   function allowance(address _owner, address _spender) override external view returns (uint256 remaining) {
+       return allows[_owner][_spender];
+   }
+
+}

contracts/business_template/redpacket/proxy.sol

@@ -0,0 +1,36 @@
+pragma solidity^0.6.10;
+import "./IERC20.sol";
+
+//负责接受积分合约的授权，以完成积分转移
+contract proxy {
+    IERC20 point;
+    address owner;
+    constructor() public {
+       owner = msg.sender; 
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "only owner can do");
+        _;
+    }
+
+    function setPointAddr(address _addr) public onlyOwner {
+        point = IERC20(_addr);
+    }
+
+    function transfer(address _from, address _to, uint256 _value) external returns (bool success) {
+        point.transferFrom(_from, _to, _value);
+    }
+
+    function allowance(address _from) public view returns (uint256) {
+        return point.allowance(_from, address(this));
+    }
+
+    function balanceOf(address _who) public view returns (uint256) {
+        return point.balanceOf(_who);
+    }
+
+    function addr() public view returns (address) {
+        return address(this);
+    }
+}

contracts/business_template/redpacket/redpacket.sol

@@ -0,0 +1,73 @@
+pragma solidity^0.6.10;
+import "./SafeMath.sol";
+import "./proxy.sol";
+
+contract redpacket {
+    //定义土豪
+    address theRich;
+    //定义红包的数据
+    uint256 public totalAmount;//红包金额
+    uint256 public leftAmount;//剩余金额
+    uint256 public count;//红包数量
+    bool    isEqual;//是否等额
+    proxy proxyContract;//红包的合约地址
+    using SafeMath for uint256;
+    //抢过了不能再抢
+    mapping(address=>bool) isGrabed;
+
+    //构造函数：土豪执行，顺带将红包也发了
+    constructor() public  {
+        proxyContract = new proxy();//创建代理合约对象
+
+    }
+
+    //调用前，用户需要先调用积分合约的授权给本合约
+    function sendRedPacket(uint256 c, bool ok, address addr, uint256 amount) public {
+        require(count == 0, "the red packet already exists");
+        require(address(0) != addr, "addr is 0");
+        require(amount > 0, "amount is 0");
+        require(c > 0, "c is 0");
+        isEqual = ok;
+        count   = c;
+        proxyContract.setPointAddr(addr);//绑定要发送的积分合约地址
+        require(proxyContract.balanceOf(msg.sender) > 0, "user's balance not enough");
+        leftAmount = totalAmount = amount;
+        theRich = msg.sender;
+
+
+    }
+
+    //抢红包
+    function grabRedpacket() public  {
+        require(count > 0, "count must > 0");
+        require(leftAmount > 0, "leftAmount must > 0");
+        require(!isGrabed[msg.sender], "msg.sender must has not grabed");
+        isGrabed[msg.sender] = true;
+
+        //如果是最后一个红包-- 直接拿走
+        if(count == 1) {
+            proxyContract.transfer(theRich, msg.sender, leftAmount);
+            leftAmount = 0;
+        } else {
+            //是否为等额
+            if(isEqual) {
+               uint256 amount = leftAmount / count;
+               leftAmount = leftAmount.sub(amount);
+               proxyContract.transfer(theRich, msg.sender, amount);
+            } else {
+                //计算一个10以内的随机值 
+                uint256 random = uint256(keccak256(abi.encode(msg.sender, theRich, count, leftAmount, now))) % 8 + 1;
+                uint256 amount = totalAmount * random / 10;
+                proxyContract.transfer(theRich, msg.sender, amount);
+                leftAmount = leftAmount.sub(amount);
+
+            }
+        }
+        count --;
+
+    }
+
+    function getProxy() public view returns (address) {
+        return proxyContract.addr();
+    }
+}