feat: sand contract

packages/sand/.gitignore

@@ -0,0 +1,13 @@
+.env
+yarn.error.log
+yarn-error.log
+.yalc
+yalc.lock
+coverage*
+.vscode/*
+node_modules/
+.idea/
+.DS_Store
+typechain-types/
+artifacts/
+cache/

packages/sand/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 The Sandbox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/sand/contracts/@openzeppelin/contracts-0.8/access/Ownable.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "../utils/Context.sol";
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * By default, the owner account will be the one that deploys the contract. This
+ * can later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev Initializes the contract setting the deployer as the initial owner.
+     */
+    constructor () {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    /**
+     * @dev Returns the address of the current owner.
+     */
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    /**
+     * @dev Leaves the contract without owner. It will not be possible to call
+     * `onlyOwner` functions anymore. Can only be called by the current owner.
+     *
+     * NOTE: Renouncing ownership will leave the contract without an owner,
+     * thereby removing any functionality that is only available to the owner.
+     */
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Can only be called by the current owner.
+     */
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+}

packages/sand/contracts/@openzeppelin/contracts-0.8/utils/Context.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/*
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return msg.data;
+    }
+}

packages/sand/contracts/contracts_common/src/BaseWithStorage/Admin.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.2;
+
+contract Admin {
+
+    address internal _admin;
+
+    event AdminChanged(address oldAdmin, address newAdmin);
+
+    /// @notice gives the current administrator of this contract.
+    /// @return the current administrator of this contract.
+    function getAdmin() external view returns (address) {
+        return _admin;
+    }
+
+    /// @notice change the administrator to be `newAdmin`.
+    /// @param newAdmin address of the new administrator.
+    function changeAdmin(address newAdmin) external {
+        require(msg.sender == _admin, "only admin can change admin");
+        emit AdminChanged(_admin, newAdmin);
+        _admin = newAdmin;
+    }
+}

packages/sand/contracts/contracts_common/src/BaseWithStorage/SuperOperators.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.5.2;
+
+import "./Admin.sol";
+
+contract SuperOperators is Admin {
+
+    mapping(address => bool) internal _superOperators;
+
+    event SuperOperator(address superOperator, bool enabled);
+
+    /// @notice Enable or disable the ability of `superOperator` to transfer tokens of all (superOperator rights).
+    /// @param superOperator address that will be given/removed superOperator right.
+    /// @param enabled set whether the superOperator is enabled or disabled.
+    function setSuperOperator(address superOperator, bool enabled) external {
+        require(
+            msg.sender == _admin,
+            "only admin is allowed to add super operators"
+        );
+        _superOperators[superOperator] = enabled;
+        emit SuperOperator(superOperator, enabled);
+    }
+
+    /// @notice check whether address `who` is given superOperator rights.
+    /// @param who The address to query.
+    /// @return whether the address has superOperator rights.
+    function isSuperOperator(address who) public view returns (bool) {
+        return _superOperators[who];
+    }
+}

packages/sand/contracts/contracts_common/src/Interfaces/ERC20Events.sol

@@ -0,0 +1,11 @@
+pragma solidity ^0.5.2;
+
+/* interface */
+contract ERC20Events {
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}

packages/sand/contracts/contracts_common/src/Libraries/BytesUtil.sol

@@ -0,0 +1,137 @@
+pragma solidity ^0.5.2;
+
+library BytesUtil {
+    function memcpy(uint256 dest, uint256 src, uint256 len) internal pure {
+        // Copy word-length chunks while possible
+        for (; len >= 32; len -= 32) {
+            assembly {
+                mstore(dest, mload(src))
+            }
+            dest += 32;
+            src += 32;
+        }
+
+        // Copy remaining bytes
+        uint256 mask = 256**(32 - len) - 1;
+        assembly {
+            let srcpart := and(mload(src), not(mask))
+            let destpart := and(mload(dest), mask)
+            mstore(dest, or(destpart, srcpart))
+        }
+    }
+
+    function pointerToBytes(uint256 src, uint256 len)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        bytes memory ret = new bytes(len);
+        uint256 retptr;
+        assembly {
+            retptr := add(ret, 32)
+        }
+
+        memcpy(retptr, src, len);
+        return ret;
+    }
+
+    function addressToBytes(address a) internal pure returns (bytes memory b) {
+        assembly {
+            let m := mload(0x40)
+            mstore(
+                add(m, 20),
+                xor(0x140000000000000000000000000000000000000000, a)
+            )
+            mstore(0x40, add(m, 52))
+            b := m
+        }
+    }
+
+    function uint256ToBytes(uint256 a) internal pure returns (bytes memory b) {
+        assembly {
+            let m := mload(0x40)
+            mstore(add(m, 32), a)
+            mstore(0x40, add(m, 64))
+            b := m
+        }
+    }
+
+    function doFirstParamEqualsAddress(bytes memory data, address _address)
+        internal
+        pure
+        returns (bool)
+    {
+        if (data.length < (36 + 32)) {
+            return false;
+        }
+        uint256 value;
+        assembly {
+            value := mload(add(data, 36))
+        }
+        return value == uint256(_address);
+    }
+
+    function doParamEqualsUInt256(bytes memory data, uint256 i, uint256 value)
+        internal
+        pure
+        returns (bool)
+    {
+        if (data.length < (36 + (i + 1) * 32)) {
+            return false;
+        }
+        uint256 offset = 36 + i * 32;
+        uint256 valuePresent;
+        assembly {
+            valuePresent := mload(add(data, offset))
+        }
+        return valuePresent == value;
+    }
+
+    function overrideFirst32BytesWithAddress(
+        bytes memory data,
+        address _address
+    ) internal pure returns (bytes memory) {
+        uint256 dest;
+        assembly {
+            dest := add(data, 48)
+        } // 48 = 32 (offset) + 4 (func sig) + 12 (address is only 20 bytes)
+
+        bytes memory addressBytes = addressToBytes(_address);
+        uint256 src;
+        assembly {
+            src := add(addressBytes, 32)
+        }
+
+        memcpy(dest, src, 20);
+        return data;
+    }
+
+    function overrideFirstTwo32BytesWithAddressAndInt(
+        bytes memory data,
+        address _address,
+        uint256 _value
+    ) internal pure returns (bytes memory) {
+        uint256 dest;
+        uint256 src;
+
+        assembly {
+            dest := add(data, 48)
+        } // 48 = 32 (offset) + 4 (func sig) + 12 (address is only 20 bytes)
+        bytes memory bbytes = addressToBytes(_address);
+        assembly {
+            src := add(bbytes, 32)
+        }
+        memcpy(dest, src, 20);
+
+        assembly {
+            dest := add(data, 68)
+        } // 48 = 32 (offset) + 4 (func sig) + 32 (next slot)
+        bbytes = uint256ToBytes(_value);
+        assembly {
+            src := add(bbytes, 32)
+        }
+        memcpy(dest, src, 32);
+
+        return data;
+    }
+}

packages/sand/contracts/src/Sand.sol

@@ -0,0 +1,27 @@
+pragma solidity 0.5.9;
+
+import "./Sand/erc20/ERC20ExecuteExtension.sol";
+import "./Sand/erc20/ERC20BaseToken.sol";
+import "./Sand/erc20/ERC20BasicApproveExtension.sol";
+
+contract Sand is ERC20ExecuteExtension, ERC20BasicApproveExtension, ERC20BaseToken {
+
+    constructor(address sandAdmin, address executionAdmin, address beneficiary) public {
+        _admin = sandAdmin;
+        _executionAdmin = executionAdmin;
+        _mint(beneficiary, 3000000000000000000000000000);
+    }
+
+    /// @notice A descriptive name for the tokens
+    /// @return name of the tokens
+    function name() public view returns (string memory) {
+        return "SAND";
+    }
+
+    /// @notice An abbreviated name for the tokens
+    /// @return symbol of the tokens
+    function symbol() public view returns (string memory) {
+        return "SAND";
+    }
+
+}