Cryo Explorer Ethereum Mainnet

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity >=0.4.25;

/**
 * @dev Contract type mapping.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
contract Type {
    uint256 constant PRIME = 1;

    uint256 public bwtype;
    uint256 public bwver;
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity >=0.6.10;

/**
 * @dev Unified system for arbitrary user groups.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
library Groups {
    struct MemberMap {
        mapping(address => bool) members;
    }

    struct GroupMap {
        mapping(uint8 => MemberMap) groups;
    }

    /**
     * @dev Add an account to a group
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function add(
        GroupMap storage map,
        uint8 groupId,
        address account
    ) internal {
        MemberMap storage group = map.groups[groupId];
        require(account != address(0));
        require(!groupContains(group, account));

        group.members[account] = true;
    }

    /**
     * @dev Remove an account from a group
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function remove(
        GroupMap storage map,
        uint8 groupId,
        address account
    ) internal {
        MemberMap storage group = map.groups[groupId];
        require(account != address(0));
        require(groupContains(group, account));

        group.members[account] = false;
    }

    /**
     * @dev Returns true if the account is in the group
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     * @return bool
     */
    function contains(
        GroupMap storage map,
        uint8 groupId,
        address account
    ) internal view returns (bool) {
        MemberMap storage group = map.groups[groupId];
        return groupContains(group, account);
    }

    function groupContains(MemberMap storage group, address account) internal view returns (bool) {
        require(account != address(0));
        return group.members[account];
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity ^0.6.10;

import "./__SafeMath.sol";

/**
 * @dev Suggestions and Voting for token-holders.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
contract Voting {
    using SafeMath for uint256;

    struct Suggestion {
        uint256 votes;
        bool created;
        address creator;
        string text;
    }

    // This stores how many votes a user has cast on a suggestion
    mapping(uint256 => mapping(address => uint256)) private voted;

    // This map stores the suggestions, and they're retrieved using their ID number
    mapping(uint256 => Suggestion) internal suggestions;

    // This keeps track of the number of suggestions in the system
    uint256 public suggestionCount;

    // If true, a wallet can only vote on a suggestion once
    bool public oneVotePerAccount = true;

    event SuggestionCreated(uint256 suggestionId, string text);
    event Votes(
        address voter,
        uint256 indexed suggestionId,
        uint256 votes,
        uint256 totalVotes,
        string comment
    );

    /**
     * @dev Gets the number of votes a suggestion has received.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getVotes(uint256 suggestionId) public view returns (uint256) {
        return suggestions[suggestionId].votes;
    }

    /**
     * @dev Gets the number of votes for every suggestion in the contract.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getAllVotes() public view returns (uint256[] memory) {
        uint256[] memory votes = new uint256[](suggestionCount);

        for (uint256 i = 0; i < suggestionCount; i++) {
            votes[i] = suggestions[i].votes;
        }

        return votes;
    }

    /**
     * @dev Gets the text of a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getSuggestionText(uint256 suggestionId) public view returns (string memory) {
        return suggestions[suggestionId].text;
    }

    /**
     * @dev Gets whether or not an account has voted for a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function hasVoted(address account, uint256 suggestionId) public view returns (bool) {
        return voted[suggestionId][account] > 0;
    }

    /**
     * @dev Gets the number of votes an account has cast towards a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getAccountVotes(address account, uint256 suggestionId) public view returns (uint256) {
        return voted[suggestionId][account];
    }

    /**
     * @dev Gets the creator of a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getSuggestionCreator(uint256 suggestionId) public view returns (address) {
        return suggestions[suggestionId].creator;
    }

    /**
     * @dev Gets the creator for every suggestion in the contract.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getAllSuggestionCreators() public view returns (address[] memory) {
        address[] memory creators = new address[](suggestionCount);

        for (uint256 i = 0; i < suggestionCount; i++) {
            creators[i] = suggestions[i].creator;
        }

        return creators;
    }

    /**
     * @dev Internal logic for creating a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function _createSuggestion(string memory text) internal {
        // The ID is just based on the suggestion count, so the IDs go 0, 1, 2, etc.
        uint256 suggestionId = suggestionCount++;

        // Starts at 0 votes
        suggestions[suggestionId] = Suggestion(0, true, msg.sender, text);

        emit SuggestionCreated(suggestionId, text);
    }

    /**
     * @dev Internal logic for voting.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function _vote(
        address account,
        uint256 suggestionId,
        uint256 votes,
        string memory comment
    ) internal returns (uint256) {
        if (oneVotePerAccount) {
            require(!hasVoted(account, suggestionId));
            require(votes == 1);
        }
        Suggestion storage sugg = suggestions[suggestionId];
        require(sugg.created);

        voted[suggestionId][account] = voted[suggestionId][account].add(votes);
        sugg.votes = sugg.votes.add(votes);

        emit Votes(account, suggestionId, votes, sugg.votes, comment);

        return sugg.votes;
    }
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity >=0.6.10;

interface Erc20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.10;

/**
 * @dev Pausing logic that includes whether the pause was initiated by an attorney.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
contract Pausable {
    struct PauseState {
        bool paused;
        bool pausedByAttorney;
    }

    PauseState private pauseState;

    event Paused(address account, bool attorney);
    event Unpaused(address account);

    constructor() internal {
        pauseState = PauseState(false, false);
    }

    modifier whenNotPaused() {
        require(!pauseState.paused);
        _;
    }

    modifier whenPaused() {
        require(pauseState.paused);
        _;
    }

    function paused() public view returns (bool) {
        return pauseState.paused;
    }

    /**
     * @dev Check if the pause was initiated by an attorney.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function pausedByAttorney() public view returns (bool) {
        return pauseState.paused && pauseState.pausedByAttorney;
    }

    /**
     * @dev Internal logic for pausing the contract.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function _pause(bool attorney) internal {
        pauseState.paused = true;
        pauseState.pausedByAttorney = attorney;
        emit Paused(msg.sender, attorney);
    }

    /**
     * @dev Internal logic for unpausing the contract.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function _unpause() internal {
        pauseState.paused = false;
        pauseState.pausedByAttorney = false;
        emit Unpaused(msg.sender);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.10;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 *
 * Originally from https://github.com/OpenZeppelin/openzeppelin-contracts
 * Copyright (c) 2016-2020 zOS Global Limited
 */
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) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 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;
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity >=0.4.25;

/**
 * Gas-efficient error codes and replacement for require.
 *
 * This uses significantly less gas, and reduces the length of the contract bytecode.
 */
contract ErrorCodes {

    bytes2 constant ERROR_RESERVED = 0xe100;
    bytes2 constant ERROR_RESERVED2 = 0xe200;
    bytes2 constant ERROR_MATH = 0xe101;
    bytes2 constant ERROR_FROZEN = 0xe102;
    bytes2 constant ERROR_INVALID_ADDRESS = 0xe103;
    bytes2 constant ERROR_ZERO_VALUE = 0xe104;
    bytes2 constant ERROR_INSUFFICIENT_BALANCE = 0xe105;
    bytes2 constant ERROR_WRONG_TIME = 0xe106;
    bytes2 constant ERROR_EMPTY_ARRAY = 0xe107;
    bytes2 constant ERROR_LENGTH_MISMATCH = 0xe108;
    bytes2 constant ERROR_UNAUTHORIZED = 0xe109;
    bytes2 constant ERROR_DISALLOWED_STATE = 0xe10a;
    bytes2 constant ERROR_TOO_HIGH = 0xe10b;
    bytes2 constant ERROR_ERC721_CHECK = 0xe10c;
    bytes2 constant ERROR_PAUSED = 0xe10d;
    bytes2 constant ERROR_NOT_PAUSED = 0xe10e;
    bytes2 constant ERROR_ALREADY_EXISTS = 0xe10f;

    bytes2 constant ERROR_OWNER_MISMATCH = 0xe110;
    bytes2 constant ERROR_LOCKED = 0xe111;
    bytes2 constant ERROR_TOKEN_LOCKED = 0xe112;
    bytes2 constant ERROR_ATTORNEY_PAUSE = 0xe113;
    bytes2 constant ERROR_VALUE_MISMATCH = 0xe114;
    bytes2 constant ERROR_TRANSFER_FAIL = 0xe115;
    bytes2 constant ERROR_INDEX_RANGE = 0xe116;
    bytes2 constant ERROR_PAYMENT = 0xe117;

    function expect(bool pass, bytes2 code) internal pure {
        if (!pass) {
            assembly {
                mstore(0x40, code)
                revert(0x40, 0x02)
            }
        }
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity ^0.6.10;

import "./_TokenGroups.sol";
import "./__SafeMath.sol";
import "./_Voting.sol";
import "./__Erc20.sol";
import "./_BlockwellQuill.sol";
import "./_Type.sol";

/**
 * Blockwell Prime Token
 */
contract PrimeToken is Erc20, TokenGroups, Type, Voting {
    using SafeMath for uint256;
    using BlockwellQuill for BlockwellQuill.Data;

    /**
     * @dev Stores data for individual token locks used by transferAndLock.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    struct Lock {
        uint256 value;
        uint64 expiration;
        uint32 periodLength;
        uint16 periods;
        bool staking;
    }

    mapping(address => uint256) internal balances;

    mapping(address => uint256) internal stakes;

    mapping(address => mapping(address => uint256)) private allowed;

    mapping(address => Lock[]) locks;

    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public unlockTime;
    uint256 public transferLockTime;
    string public attorneyEmail;

    uint256 internal totalTokenSupply;

    uint256 public swapNonce;

    bool public suggestionsRestricted = false;
    bool public requireBalanceForVote = false;
    bool public requireBalanceForCreateSuggestion = false;
    uint256 public voteCost;

    uint256 public unstakingDelay = 1 hours;

    BlockwellQuill.Data bwQuill1;

    event SetNewUnlockTime(uint256 unlockTime);
    event MultiTransferPrevented(address indexed from, address indexed to, uint256 value);

    event Locked(
        address indexed owner,
        uint256 value,
        uint64 expiration,
        uint32 periodLength,
        uint16 periodCount
    );
    event Unlocked(address indexed owner, uint256 value, uint16 periodsLeft);

    event SwapToChain(
        string toChain,
        address indexed from,
        address indexed to,
        bytes32 indexed swapId,
        uint256 value
    );
    event SwapFromChain(
        string fromChain,
        address indexed from,
        address indexed to,
        bytes32 indexed swapId,
        uint256 value
    );

    event BwQuillSet(address indexed account, string value);

    event Payment(address indexed from, address indexed to, uint256 value, uint256 order);

    event Stake(address indexed account, uint256 value);
    event Unstake(address indexed account, uint256 value);
    event StakeReward(address indexed account, uint256 value);

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _totalSupply
    ) public {
        require(_totalSupply > 0);

        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        totalTokenSupply = _totalSupply;

        init(msg.sender);
        bwtype = PRIME;
        bwver = 62;
    }

    function init(address sender) internal virtual {
        _addBwAdmin(sender);
        _addAdmin(sender);

        balances[sender] = totalTokenSupply;
        emit Transfer(address(0), sender, totalTokenSupply);
    }

    /**
     * @dev Allow only when the contract is unlocked, or if the sender is an admin, an attorney, or whitelisted.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    modifier whenUnlocked() {
        expect(
            now > unlockTime || isAdmin(msg.sender) || isAttorney(msg.sender) || isWhitelisted(msg.sender),
            ERROR_TOKEN_LOCKED
        );
        _;
    }

    /**
     * @dev Set a quill 1 value for an account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setBwQuill(address account, string memory value) public onlyAdminOrAttorney {
        bwQuill1.setString(account, value);
        emit BwQuillSet(account, value);
    }

    /**
     * @dev Get a quill 1 value for any account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getBwQuill(address account) public view returns (string memory) {
        return bwQuill1.getString(account);
    }

    /**
     * @dev Configure how users can vote.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function configureVoting(
        bool restrictSuggestions,
        bool balanceForVote,
        bool balanceForCreateSuggestion,
        uint256 cost,
        bool oneVote
    ) public onlyAdminOrAttorney {
        suggestionsRestricted = restrictSuggestions;
        requireBalanceForVote = balanceForVote;
        requireBalanceForCreateSuggestion = balanceForCreateSuggestion;
        voteCost = cost;
        oneVotePerAccount = oneVote;
    }

    /**
     * @dev Update the email address for this token's assigned attorney.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setAttorneyEmail(string memory email) public onlyAdminOrAttorney {
        attorneyEmail = email;
    }

    /**
     * @dev Pause the contract, preventing transfers.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function pause() public whenNotPaused {
        bool attorney = isAttorney(msg.sender);
        expect(attorney || isAdmin(msg.sender), ERROR_UNAUTHORIZED);

        _pause(attorney);
    }

    /**
     * @dev Resume the contract.
     *
     * If the contract was originally paused by an attorney, only an attorney can resume.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function unpause() public whenPaused {
        if (!isAttorney(msg.sender)) {
            expect(isAdmin(msg.sender), ERROR_UNAUTHORIZED);
            expect(!pausedByAttorney(), ERROR_ATTORNEY_PAUSE);
        }
        _unpause();
    }

    /**
     * @dev Lock the contract if not already locked until the given time.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setUnlockTime(uint256 timestamp) public onlyAdminOrAttorney {
        unlockTime = timestamp;
        emit SetNewUnlockTime(unlockTime);
    }

    /**
     * @dev Total number of tokens.
     */
    function totalSupply() public view override returns (uint256) {
        return totalTokenSupply;
    }

    /**
     * @dev Get account balance.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return balances[account];
    }

    /**
     * @dev Get allowance for an owner-spender pair.
     */
    function allowance(address owner, address spender) public view override returns (uint256) {
        return allowed[owner][spender];
    }

    /**
     * @dev Transfer tokens.
     */
    function transfer(address to, uint256 value) public override whenNotPaused whenUnlocked returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Make multiple token transfers with one transaction.
     * @param to Array of addresses to transfer to.
     * @param value Array of amounts to be transferred.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiTransfer(address[] calldata to, uint256[] calldata value)
        public
        whenNotPaused
        onlyBundler
        returns (bool)
    {
        expect(to.length > 0, ERROR_EMPTY_ARRAY);
        expect(value.length == to.length, ERROR_LENGTH_MISMATCH);

        for (uint256 i = 0; i < to.length; i++) {
            if (!isFrozen(to[i])) {
                _transfer(msg.sender, to[i], value[i]);
            } else {
                emit MultiTransferPrevented(msg.sender, to[i], value[i]);
            }
        }

        return true;
    }

    /**
     * @dev Approve a spender to transfer the given amount of the sender's tokens.
     */
    function approve(address spender, uint256 value)
        public
        override
        isNotFrozen
        whenNotPaused
        whenUnlocked
        returns (bool)
    {
        expect(spender != address(0), ERROR_INVALID_ADDRESS);

        allowed[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from an account the sender has been approved to send from.
     */
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) public override whenNotPaused whenUnlocked returns (bool) {
        allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to multiple others.
     * @param from Address to send from.
     * @param to Array of addresses to transfer to.
     * @param value Array of amounts to be transferred.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiTransferFrom(
        address from,
        address[] calldata to,
        uint256[] calldata value
    ) public whenNotPaused onlyBundler returns (bool) {
        expect(to.length > 0, ERROR_EMPTY_ARRAY);
        expect(value.length == to.length, ERROR_LENGTH_MISMATCH);

        for (uint256 i = 0; i < to.length; i++) {
            if (!isFrozen(to[i])) {
                allowed[from][msg.sender] = allowed[from][msg.sender].sub(value[i]);
                _transfer(from, to[i], value[i]);
            } else {
                emit MultiTransferPrevented(from, to[i], value[i]);
            }
        }

        return true;
    }

    /**
     * @dev Increase the amount of tokens a spender can transfer from the sender's account.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        public
        isNotFrozen
        whenNotPaused
        whenUnlocked
        returns (bool)
    {
        expect(spender != address(0), ERROR_INVALID_ADDRESS);

        allowed[msg.sender][spender] = allowed[msg.sender][spender].add(addedValue);
        emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Decrease the amount of tokens a spender can transfer from the sender's account.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        isNotFrozen
        whenNotPaused
        whenUnlocked
        returns (bool)
    {
        expect(spender != address(0), ERROR_INVALID_ADDRESS);

        allowed[msg.sender][spender] = allowed[msg.sender][spender].sub(subtractedValue);
        emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
        return true;
    }

    /**
     * @dev Lists all the locks for the given account as an array, with [value1, expiration1, value2, expiration2, ...]
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function locksOf(address account) public view returns (uint256[] memory) {
        Lock[] storage userLocks = locks[account];

        uint256[] memory lockArray = new uint256[](userLocks.length * 4);

        for (uint256 i = 0; i < userLocks.length; i++) {
            uint256 pos = 4 * i;
            lockArray[pos] = userLocks[i].value;
            lockArray[pos + 1] = userLocks[i].expiration;
            lockArray[pos + 2] = userLocks[i].periodLength;
            lockArray[pos + 3] = userLocks[i].periods;
        }

        return lockArray;
    }

    /**
     * @dev Unlocks all expired locks.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function unlock() public returns (bool) {
        return _unlock(msg.sender);
    }

    /**
     * @dev Base method for unlocking tokens.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function _unlock(address account) internal returns (bool) {
        Lock[] storage list = locks[account];
        if (list.length == 0) {
            return true;
        }

        for (uint256 i = 0; i < list.length; ) {
            Lock storage lock = list[i];
            if (lock.expiration < block.timestamp) {
                // Less than 2 means it's the last period (1), or periods are not used (0)
                if (lock.periods < 2) {
                    emit Unlocked(account, lock.value, 0);

                    if (i < list.length - 1) {
                        list[i] = list[list.length - 1];
                    }
                    list.pop();
                } else {
                    uint256 value;
                    uint256 diff = block.timestamp.sub(lock.expiration);
                    uint16 periodsPassed = 1 + uint16(diff.div(lock.periodLength));
                    if (periodsPassed >= lock.periods) {
                        periodsPassed = lock.periods;
                        value = lock.value;
                        emit Unlocked(account, value, 0);
                        if (i < list.length - 1) {
                            list[i] = list[list.length - 1];
                        }
                        list.pop();
                    } else {
                        value = lock.value.div(lock.periods) * periodsPassed;

                        lock.periods -= periodsPassed;
                        lock.value = lock.value.sub(value);
                        lock.expiration =
                            lock.expiration +
                            uint32(uint256(lock.periodLength).mul(periodsPassed));
                        emit Unlocked(account, value, lock.periods);
                        i++;
                    }
                }
            } else {
                i++;
            }
        }

        return true;
    }

    /**
     * @dev Gets the unlocked balance of the specified address.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function unlockedBalanceOf(address account) public view returns (uint256) {
        return balances[account].sub(totalLocked(account));
    }

    /**
     * @dev Gets the total usable tokens for an account, including tokens that could be unlocked.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function availableBalanceOf(address account) external view returns (uint256) {
        return balances[account].sub(totalLocked(account)).add(totalUnlockable(account));
    }

    /**
     * @dev Transfers tokens and locks them for lockTime.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function transferAndLock(
        address to,
        uint256 value,
        uint32 lockTime,
        uint32 periodLength,
        uint16 periods
    ) public returns (bool) {
        uint64 expires = uint64(block.timestamp.add(lockTime));
        Lock memory newLock = Lock(value, expires, periodLength, periods, false);
        locks[to].push(newLock);

        transfer(to, value);
        emit Locked(to, value, expires, periodLength, periods);

        return true;
    }

    /**
     * @dev Transfer and lock to multiple accounts with a single transaction.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiTransferAndLock(
        address[] calldata to,
        uint256[] calldata value,
        uint32 lockTime,
        uint32 periodLength,
        uint16 periods
    ) public whenNotPaused onlyBundler returns (bool) {
        expect(to.length > 0, ERROR_EMPTY_ARRAY);
        expect(value.length == to.length, ERROR_LENGTH_MISMATCH);

        for (uint256 i = 0; i < to.length; i++) {
            if (!isFrozen(to[i])) {
                transferAndLock(to[i], value[i], lockTime, periodLength, periods);
            } else {
                emit MultiTransferPrevented(msg.sender, to[i], value[i]);
            }
        }

        return true;
    }

    /**
     * @dev Gets the total amount of locked tokens in the given account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function totalLocked(address account) public view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 0; i < locks[account].length; i++) {
            total = total.add(locks[account][i].value);
        }

        return total;
    }

    /**
     * @dev Gets the amount of tokens that can currently be unlocked.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function totalUnlockable(address account) public view returns (uint256) {
        Lock[] storage userLocks = locks[account];
        uint256 total = 0;
        for (uint256 i = 0; i < userLocks.length; i++) {
            Lock storage lock = userLocks[i];
            if (lock.expiration < block.timestamp) {
                if (lock.periods < 2) {
                    total = total.add(lock.value);
                } else {
                    uint256 value;
                    uint256 diff = block.timestamp.sub(lock.expiration);
                    uint16 periodsPassed = 1 + uint16(diff.div(lock.periodLength));
                    if (periodsPassed > lock.periods) {
                        periodsPassed = lock.periods;
                        value = lock.value;
                    } else {
                        value = lock.value.div(lock.periods) * periodsPassed;
                    }

                    total = total.add(value);
                }
            }
        }

        return total;
    }

    /**
     * @dev Withdraw any tokens the contract itself is holding.
     */
    function withdrawTokens() public whenNotPaused {
        expect(isAdmin(msg.sender), ERROR_UNAUTHORIZED);
        _transfer(address(this), msg.sender, balanceOf(address(this)));
    }

    /**
     * @dev Gets an incrementing nonce for generating swap IDs.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getSwapNonce() internal returns (uint256) {
        return ++swapNonce;
    }

    /**
     * @dev Initiates a swap to another chain. Transfers the tokens to this contract and emits an event
     *      indicating the request to swap.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function swapToChain(
        string memory chain,
        address to,
        uint256 value
    ) public whenNotPaused whenUnlocked {
        bytes32 swapId = keccak256(
            abi.encodePacked(getSwapNonce(), msg.sender, to, address(this), chain, value)
        );

        _transfer(msg.sender, address(this), value);
        emit SwapToChain(chain, msg.sender, to, swapId, value);
    }

    /**
     * @dev Completes a swap from another chain, called by a swapper account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function swapFromChain(
        string memory fromChain,
        address from,
        address to,
        bytes32 swapId,
        uint256 value
    ) public whenNotPaused onlySwapper {
        _transfer(address(this), to, value);

        emit SwapFromChain(fromChain, from, to, swapId, value);
    }

    /**
     * @dev Create a new suggestion for voting.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function createSuggestion(string memory text) public {
        if (suggestionsRestricted) {
            expect(isAdmin(msg.sender) || isDelegate(msg.sender), ERROR_UNAUTHORIZED);
        } else if (requireBalanceForCreateSuggestion) {
            expect(balanceOf(msg.sender) > 0, ERROR_INSUFFICIENT_BALANCE);
        }
        _createSuggestion(text);
    }

    /**
     * @dev Vote on a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function vote(uint256 suggestionId, string memory comment) public {
        if (requireBalanceForVote) {
            expect(balanceOf(msg.sender) > 0, ERROR_INSUFFICIENT_BALANCE);
        }

        if (voteCost > 0) {
            _transfer(msg.sender, address(this), voteCost);
        }

        _vote(msg.sender, suggestionId, 1, comment);
    }

    /**
     * @dev Cast multiple votes on a suggestion.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiVote(
        uint256 suggestionId,
        uint256 votes,
        string memory comment
    ) public {
        expect(!oneVotePerAccount, ERROR_DISALLOWED_STATE);

        if (requireBalanceForVote) {
            expect(balanceOf(msg.sender) > 0, ERROR_INSUFFICIENT_BALANCE);
        }

        if (voteCost > 0) {
            _transfer(msg.sender, address(this), voteCost.mul(votes));
        }

        _vote(msg.sender, suggestionId, votes, comment);
    }

    /**
     * @dev Transfer tokens and include an order number for external reference.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function payment(
        address to,
        uint256 value,
        uint256 order
    ) public whenNotPaused whenUnlocked returns (bool) {
        _transfer(msg.sender, to, value);

        emit Payment(msg.sender, to, value, order);
        return true;
    }

    /**
     * @dev Stake tokens, locking them for a minimum of unstakingDelay time.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function stake(uint256 value) public whenNotPaused whenUnlocked returns (bool) {
        expect(!isFrozen(msg.sender), ERROR_FROZEN);

        _unlock(msg.sender);
        expect(value <= unlockedBalanceOf(msg.sender), ERROR_INSUFFICIENT_BALANCE);

        balances[msg.sender] = balances[msg.sender].sub(value);
        stakes[msg.sender] = stakes[msg.sender].add(value);

        emit Transfer(msg.sender, address(0), value);
        emit Stake(msg.sender, value);

        return true;
    }

    /**
     * @dev Get the total staked tokens for an account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function stakeOf(address account) public view returns (uint256) {
        return stakes[account];
    }

    /**
     * @dev Unstake tokens, which will lock them for unstakingDelay time.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function unstake(uint256 value) public whenNotPaused whenUnlocked returns (bool) {
        expect(!isFrozen(msg.sender), ERROR_FROZEN);

        stakes[msg.sender] = stakes[msg.sender].sub(value);
        balances[msg.sender] = balances[msg.sender].add(value);

        if (unstakingDelay > 0) {
            uint64 expires = uint64(block.timestamp.add(unstakingDelay));
            Lock memory newLock = Lock(value, expires, 0, 0, true);
            locks[msg.sender].push(newLock);
            emit Locked(msg.sender, value, expires, 0, 0);
        }

        emit Unstake(msg.sender, value);
        emit Transfer(address(0), msg.sender, value);

        return true;
    }

    /**
     * @dev Configure staking parameters.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function configureStaking(uint256 unstakeDelay) public onlyAdminOrAttorney {
        unstakingDelay = unstakeDelay;
    }

    /**
     * @dev Reward tokens to account stake balances.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function stakeReward(address[] calldata to, uint256[] calldata value)
        public
        whenNotPaused
        returns (bool)
    {
        expect(isAutomator(msg.sender), ERROR_UNAUTHORIZED);
        expect(value.length == to.length, ERROR_LENGTH_MISMATCH);

        for (uint256 i = 0; i < to.length; i++) {
            address account = to[i];
            uint256 val = value[i];
            if (!isFrozen(account)) {
                stakes[account] = stakes[account].add(val);
                balances[msg.sender] = balances[msg.sender].sub(val);

                emit StakeReward(account, val);
                emit Transfer(msg.sender, address(0), val);
            }
        }

        return true;
    }

    /**
     * @dev Base method for transferring tokens.
     */
    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        expect(to != address(0), ERROR_INVALID_ADDRESS);
        expect(!isFrozen(from), ERROR_FROZEN);
        expect(!isFrozen(to), ERROR_FROZEN);

        _unlock(from);

        expect(value <= unlockedBalanceOf(from), ERROR_INSUFFICIENT_BALANCE);

        balances[from] = balances[from].sub(value);
        balances[to] = balances[to].add(value);
        emit Transfer(from, to, value);
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity ^0.6.10;

import "./_Pausable.sol";
import "./_ErrorCodes.sol";
import "./_Groups.sol";

/**
 * @dev User groups for Prime Token.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
contract TokenGroups is Pausable, ErrorCodes {
    uint8 public constant ADMIN = 1;
    uint8 public constant ATTORNEY = 2;
    uint8 public constant BUNDLER = 3;
    uint8 public constant WHITELIST = 4;
    uint8 public constant FROZEN = 5;
    uint8 public constant BW_ADMIN = 6;
    uint8 public constant SWAPPER = 7;
    uint8 public constant DELEGATE = 8;
    uint8 public constant AUTOMATOR = 11;

    using Groups for Groups.GroupMap;

    Groups.GroupMap groups;

    event AddedToGroup(uint8 indexed groupId, address indexed account);
    event RemovedFromGroup(uint8 indexed groupId, address indexed account);

    event BwAddedAttorney(address indexed account);
    event BwRemovedAttorney(address indexed account);
    event BwRemovedAdmin(address indexed account);

    modifier onlyAdminOrAttorney() {
        expect(isAdmin(msg.sender) || isAttorney(msg.sender), ERROR_UNAUTHORIZED);
        _;
    }

    // ATTORNEY

    function _addAttorney(address account) internal {
        _add(ATTORNEY, account);
    }

    function addAttorney(address account) public whenNotPaused onlyAdminOrAttorney {
        _add(ATTORNEY, account);
    }

    /**
     * @dev Allows BW admins to add an attorney to the contract in emergency cases.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function bwAddAttorney(address account) public onlyBwAdmin {
        _add(ATTORNEY, account);
        emit BwAddedAttorney(account);
    }

    function removeAttorney(address account) public whenNotPaused onlyAdminOrAttorney {
        _remove(ATTORNEY, account);
    }

    /**
     * @dev Allows BW admins to remove an attorney from the contract in emergency cases.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function bwRemoveAttorney(address account) public onlyBwAdmin {
        _remove(ATTORNEY, account);
        emit BwRemovedAttorney(account);
    }

    function isAttorney(address account) public view returns (bool) {
        return _contains(ATTORNEY, account);
    }

    // ADMIN

    function _addAdmin(address account) internal {
        _add(ADMIN, account);
    }

    function addAdmin(address account) public whenNotPaused onlyAdminOrAttorney {
        _addAdmin(account);
    }

    function removeAdmin(address account) public whenNotPaused onlyAdminOrAttorney {
        _remove(ADMIN, account);
    }

    /**
     * @dev Allows BW admins to remove an admin from the contract in emergency cases.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function bwRemoveAdmin(address account) public onlyBwAdmin {
        _remove(ADMIN, account);
        emit BwRemovedAdmin(account);
    }

    function isAdmin(address account) public view returns (bool) {
        return _contains(ADMIN, account);
    }

    // BUNDLER

    function addBundler(address account) public onlyAdminOrAttorney {
        _add(BUNDLER, account);
    }

    function removeBundler(address account) public onlyAdminOrAttorney {
        _remove(BUNDLER, account);
    }

    function isBundler(address account) public view returns (bool) {
        return _contains(BUNDLER, account);
    }

    modifier onlyBundler() {
        expect(isBundler(msg.sender), ERROR_UNAUTHORIZED);
        _;
    }

    // SWAPPER

    function addSwapper(address account) public onlyAdminOrAttorney {
        _addSwapper(account);
    }

    function _addSwapper(address account) internal {
        _add(SWAPPER, account);
    }

    function removeSwapper(address account) public onlyAdminOrAttorney {
        _remove(SWAPPER, account);
    }

    function isSwapper(address account) public view returns (bool) {
        return _contains(SWAPPER, account);
    }

    modifier onlySwapper() {
        expect(isSwapper(msg.sender), ERROR_UNAUTHORIZED);
        _;
    }

    // WHITELIST

    function addToWhitelist(address account) public onlyAdminOrAttorney {
        _add(WHITELIST, account);
    }

    function removeFromWhitelist(address account) public onlyAdminOrAttorney {
        _remove(WHITELIST, account);
    }

    function isWhitelisted(address account) public view returns (bool) {
        return _contains(WHITELIST, account);
    }

    // BW_ADMIN

    function _addBwAdmin(address account) internal {
        _add(BW_ADMIN, account);
    }

    function addBwAdmin(address account) public onlyBwAdmin {
        _addBwAdmin(account);
    }

    function renounceBwAdmin() public {
        _remove(BW_ADMIN, msg.sender);
    }

    function isBwAdmin(address account) public view returns (bool) {
        return _contains(BW_ADMIN, account);
    }

    modifier onlyBwAdmin() {
        expect(isBwAdmin(msg.sender), ERROR_UNAUTHORIZED);
        _;
    }

    // FROZEN

    function _freeze(address account) internal {
        _add(FROZEN, account);
    }

    function freeze(address account) public onlyAdminOrAttorney {
        _freeze(account);
    }

    function _unfreeze(address account) internal {
        _remove(FROZEN, account);
    }

    function unfreeze(address account) public onlyAdminOrAttorney {
        _unfreeze(account);
    }

    /**
     * @dev Freeze multiple accounts with a single transaction.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiFreeze(address[] calldata account) public onlyAdminOrAttorney {
        expect(account.length > 0, ERROR_EMPTY_ARRAY);

        for (uint256 i = 0; i < account.length; i++) {
            _freeze(account[i]);
        }
    }

    /**
     * @dev Unfreeze multiple accounts with a single transaction.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function multiUnfreeze(address[] calldata account) public onlyAdminOrAttorney {
        expect(account.length > 0, ERROR_EMPTY_ARRAY);

        for (uint256 i = 0; i < account.length; i++) {
            _unfreeze(account[i]);
        }
    }

    function isFrozen(address account) public view returns (bool) {
        return _contains(FROZEN, account);
    }

    modifier isNotFrozen() {
        expect(!isFrozen(msg.sender), ERROR_FROZEN);
        _;
    }

    // DELEGATE

    function addDelegate(address account) public onlyAdminOrAttorney {
        _add(DELEGATE, account);
    }

    function removeDelegate(address account) public onlyAdminOrAttorney {
        _remove(DELEGATE, account);
    }

    function isDelegate(address account) public view returns (bool) {
        return _contains(DELEGATE, account);
    }

    // AUTOMATOR

    function addAutomator(address account) public onlyAdminOrAttorney {
        _add(AUTOMATOR, account);
    }

    function removeAutomator(address account) public onlyAdminOrAttorney {
        _remove(AUTOMATOR, account);
    }

    function isAutomator(address account) public view returns (bool) {
        return _contains(AUTOMATOR, account);
    }

    // Internal functions

    function _add(uint8 groupId, address account) internal {
        groups.add(groupId, account);
        emit AddedToGroup(groupId, account);
    }

    function _remove(uint8 groupId, address account) internal {
        groups.remove(groupId, account);
        emit RemovedFromGroup(groupId, account);
    }

    function _contains(uint8 groupId, address account) internal view returns (bool) {
        return groups.contains(groupId, account);
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License

/*
______      __           _
|  _  \    / _|         | |
| | | |___| |_ __ _  ___| |_ ___  _ __
| | | / _ \  _/ _` |/ __| __/ _ \| '__|
| |/ /  __/ || (_| | (__| || (_) | |
|___/ \___|_| \__,_|\___|\__\___/|_|

Defactor provides a gateway for traditional businesses to access the billions
of dollars currently available in Decentralized Finance (DeFi) liquidity pools,
offering a pipeline of real-world assets that can bring enormous value to the
DeFi ecosystem. Defactor will spawn new business models and new financial
products and services based on DeFi.  Defactor will help cement DeFi as a true
competitor to traditional finance.

For more information about the project visit https://www.defactor.com

*/
pragma solidity ^0.6.10;

import "./_PrimeToken.sol";

/**
 * @dev Extended constructor for added user groups and deployment fees.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
contract PrimeDeployable is PrimeToken {
    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _totalSupply,
        address owner,
        address bwAdmin,
        address feeAccount,
        uint256 feePercentageTenths,
        address attorney,
        string memory _attorneyEmail
    ) public PrimeToken(_name, _symbol, _decimals, _totalSupply) {
        _addBwAdmin(bwAdmin);
        _addAdmin(owner);
        if (attorney != address(0x0)) {
            _addAttorney(attorney);
        }
        attorneyEmail = _attorneyEmail;

        // Percentage should be in tenths, so 1% would be 10
        if (feePercentageTenths > 0) {
            uint256 fee = totalTokenSupply.mul(feePercentageTenths).div(1000);
            balances[owner] = totalTokenSupply.sub(fee);
            emit Transfer(address(0), owner, balances[owner]);

            balances[feeAccount] = fee;
            emit Transfer(address(0), feeAccount, fee);
        } else {
            balances[owner] = totalTokenSupply;
            emit Transfer(address(0), owner, totalTokenSupply);
        }
    }

    function init(address) internal override {
        // Skip the original init function
    }
}

// SPDX-License-Identifier: LicenseRef-Blockwell-Smart-License
pragma solidity ^0.6.10;

/**
 * @dev Blockwell Quill, storing arbitrary data associated with accounts.
 *
 * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
 */
library BlockwellQuill {
    struct Data {
        mapping(address => bytes) data;
    }

    /**
     * @dev Set data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function set(
        Data storage data,
        address account,
        bytes memory value
    ) internal {
        require(account != address(0));
        data.data[account] = value;
    }

    /**
     * @dev Get data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function get(Data storage data, address account) internal view returns (bytes memory) {
        require(account != address(0));
        return data.data[account];
    }

    /**
     * @dev Convert and set string data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setString(
        Data storage data,
        address account,
        string memory value
    ) internal {
        data.data[address(account)] = bytes(value);
    }

    /**
     * @dev Get and convert string data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getString(Data storage data, address account) internal view returns (string memory) {
        return string(data.data[address(account)]);
    }

    /**
     * @dev Convert and set uint256 data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setUint256(
        Data storage data,
        address account,
        uint256 value
    ) internal {
        data.data[address(account)] = abi.encodePacked(value);
    }

    /**
     * @dev Get and convert uint256 data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getUint256(Data storage data, address account) internal view returns (uint256) {
        uint256 ret;
        bytes memory source = data.data[address(account)];
        assembly {
            ret := mload(add(source, 32))
        }
        return ret;
    }

    /**
     * @dev Convert and set address data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function setAddress(
        Data storage data,
        address account,
        address value
    ) internal {
        data.data[address(account)] = abi.encodePacked(value);
    }

    /**
     * @dev Get and convert address data on the account.
     *
     * Blockwell Exclusive (Intellectual Property that lives on-chain via Smart License)
     */
    function getAddress(Data storage data, address account) internal view returns (address) {
        address ret;
        bytes memory source = data.data[address(account)];
        assembly {
            ret := mload(add(source, 20))
        }
        return ret;
    }
}