Swipe-Wallet/SwipeIssuing.sol at master · SwipeWallet/Swipe-Wallet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/**
 *Submitted for verification at Etherscan.io on 2019-08-16
*/

pragma solidity ^0.5.0;

import "SwipeToken.sol";

/**
 * @title SwipeIssuing
 * @company Swipe Wallet LTD
 * @URL https://www.swipe.io
 */
contract SwipeIssuing is Owned {
    using SafeMath for uint;

    struct PartnerInfo {
        bool activated;
        uint index;
        uint fee;
    }

    mapping(address => PartnerInfo) private partner_info;
    address[] private partners;

    uint lockEligibleAmount = 300000 * 10**uint(18); //300k SXP
    SwipeToken private sxpToken;

    /**
     * @dev Create a new PartnerContract
     * @param _sxpToken address of SwipeToken
     */
    constructor(address payable _sxpToken) public {
        sxpToken = SwipeToken(_sxpToken);
    }

    function isRegistered(address partner)
    public view
    returns(bool)
    {
        if(partners.length == 0) return false;
        return (partners[partner_info[partner].index] == partner);
    }

    function isActivated(address partner)
    public view
    returns(bool)
    {
        if (!isRegistered(partner)) return false;
        return partner_info[partner].activated;
    }

    /**
     * @dev Add new partner in contract partners array
     * @param partner address of new partner
     */
    function registerPartner(address partner) external onlyOwner {
        require(partner != address(0), "invalid partner address");
        require(isRegistered(partner) == false, "Already registered!");
        partner_info[partner].activated = false;
        partner_info[partner].index     = partners.push(partner)-1;
        partner_info[partner].fee = 0;
    }


    /**
     * @dev Remove partner from contract partners array
     * @param partner address of partner
     */
    function delistPartner(address partner) external onlyOwner {
        require(partner != address(0), "invalid partner address");
        require(isRegistered(partner) == true, "Not registered!");

        uint rowToDelete = partner_info[partner].index;
        address keyToMove = partners[partners.length-1];
        partners[rowToDelete] = keyToMove;
        partner_info[keyToMove].index = rowToDelete;
        partners.length--;
    }

    /**
     * @dev if partner has more than 300k SXP, 300k SXP will be locked and activate partner
     * @param partner address of partner
     */
    function activatePartner(address partner) external onlyOwner {
        require(isRegistered(partner) == true, "Not registered!");
        require(isActivated(partner) == false, "Already activated!");
        require(sxpToken.balanceOf(partner) >= lockEligibleAmount, "Insufficient balance!");
        if (sxpToken.transferFrom(partner, address(this), lockEligibleAmount)) {
            partner_info[partner].activated = true;
        }
    }

    /**
     * @dev unlock 300k SXP, and deactivate partner
     * @param partner address of partner
     */
    function deactivatePartner(address partner) external onlyOwner {
        require(isRegistered(partner) == true, "Not registered!");
        require(isActivated(partner) == true, "Not activated!");
        if (sxpToken.transfer(partner, lockEligibleAmount)) {
            partner_info[partner].activated = false;
        }
    }

    /**
     * @dev add SXP to partner as amount param
     * @param amount amount to add
     */
    function loadFees(address partner, uint amount) external onlyOwner {
        require(isRegistered(partner) == true, "Not registered!");
        require(isActivated(partner) == true, "Not activated!");
        require(sxpToken.balanceOf(partner) >= amount, "Insufficient balance!");
        if (sxpToken.transferFrom(partner, address(this), amount)) {
            partner_info[partner].fee = partner_info[partner].fee.add(amount);
        }
    }

    /**
     * @dev  burn 50% of amount param and move 50% of amount param to owner from partner's loadFees
     * @param partner address of partner
     * @param amount amount to process
     */
    function processFees(address partner, uint amount) external onlyOwner{
        require(isRegistered(partner) == true, "Not registered!");
        require(isActivated(partner) == true, "Not activated!");
        require(partner_info[partner].fee >= amount, "Insufficient fee loaded!");
        if (sxpToken.burn(amount.div(2))) {
            if (sxpToken.transfer(owner, amount.div(2))) {
                partner_info[partner].fee = partner_info[partner].fee.sub(amount);
            }
        }
    }

    /**
     * @dev  get number of activated partners
     */
    function viewPartners()
    public view
    returns(address[] memory)
    {
        uint count = 0;
        for (uint i = 0; i < partners.length; i ++) {
            if (partner_info[partners[i]].activated) {
                count ++;
            }
        }

        address[] memory ret = new address[](count);
        uint index = 0;
        for (uint i = 0; i < partners.length; i ++) {
            if (partner_info[partners[i]].activated) {
                ret[index] = partners[i];
                index ++;
            }
        }
    }
 }