feat: add interfaces

src/StdUtils.sol

@@ -7,7 +7,7 @@ abstract contract StdUtils {
     uint256 internal constant UINT256_MAX =
         115792089237316195423570985008687907853269984665640564039457584007913129639935;
 
-    function _bound(uint256 x, uint256 min, uint256 max) internal view virtual returns (uint256 result) {
+    function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
         require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
 
         // If x is between min and max, return x directly. This is to ensure that dictionary values

src/interfaces/IERC1155.sol

@@ -0,0 +1,103 @@
+pragma solidity >=0.6.2;
+
+import "src/interfaces/IERC165.sol";
+
+/// @title ERC-1155 Multi Token Standard
+/// @dev See https://eips.ethereum.org/EIPS/eip-1155
+/// Note: The ERC-165 identifier for this interface is 0xd9b67a26.
+interface ERC1155 is IERC165 {
+    /// @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
+    /// The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
+    /// The `_from` argument MUST be the address of the holder whose balance is decreased.
+    /// The `_to` argument MUST be the address of the recipient whose balance is increased.
+    /// The `_id` argument MUST be the token type being transferred.
+    /// The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
+    /// When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
+    /// When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
+    event TransferSingle(
+        address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value
+    );
+
+    /// @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
+    /// The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
+    /// The `_from` argument MUST be the address of the holder whose balance is decreased.
+    /// The `_to` argument MUST be the address of the recipient whose balance is increased.
+    /// The `_ids` argument MUST be the list of tokens being transferred.
+    /// The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
+    /// When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
+    /// When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
+    event TransferBatch(
+        address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values
+    );
+
+    /// @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled).
+    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+
+    /// @dev MUST emit when the URI is updated for a token ID.
+    /// URIs are defined in RFC 3986.
+    /// The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
+    event URI(string _value, uint256 indexed _id);
+
+    /// @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
+    /// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
+    /// MUST revert if `_to` is the zero address.
+    /// MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
+    /// MUST revert on any other error.
+    /// MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
+    /// After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
+    /// @param _from Source address
+    /// @param _to Target address
+    /// @param _id ID of the token type
+    /// @param _value Transfer amount
+    /// @param _data Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
+    function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
+
+    /// @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call).
+    /// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
+    /// MUST revert if `_to` is the zero address.
+    /// MUST revert if length of `_ids` is not the same as length of `_values`.
+    /// MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient.
+    /// MUST revert on any other error.
+    /// MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
+    /// Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
+    /// After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
+    /// @param _from Source address
+    /// @param _to Target address
+    /// @param _ids IDs of each token type (order and length must match _values array)
+    /// @param _values Transfer amounts per token type (order and length must match _ids array)
+    /// @param _data Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to`
+    function safeBatchTransferFrom(
+        address _from,
+        address _to,
+        uint256[] calldata _ids,
+        uint256[] calldata _values,
+        bytes calldata _data
+    ) external;
+
+    /// @notice Get the balance of an account's tokens.
+    /// @param _owner The address of the token holder
+    /// @param _id ID of the token
+    /// @return The _owner's balance of the token type requested
+    function balanceOf(address _owner, uint256 _id) external view returns (uint256);
+
+    /// @notice Get the balance of multiple account/token pairs
+    /// @param _owners The addresses of the token holders
+    /// @param _ids ID of the tokens
+    /// @return The _owner's balance of the token types requested (i.e. balance for each (owner, id) pair)
+    function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
+        external
+        view
+        returns (uint256[] memory);
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
+    /// @dev MUST emit the ApprovalForAll event on success.
+    /// @param _operator Address to add to the set of authorized operators
+    /// @param _approved True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address _operator, bool _approved) external;
+
+    /// @notice Queries the approval status of an operator for a given owner.
+    /// @param _owner The owner of the tokens
+    /// @param _operator Address of authorized operator
+    /// @return True if the operator is approved, false if not
+    function isApprovedForAll(address _owner, address _operator) external view returns (bool);
+}

src/interfaces/IERC165.sol

@@ -0,0 +1,11 @@
+pragma solidity >=0.6.2;
+
+interface IERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    /// uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    /// `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}

src/interfaces/IERC20.sol

@@ -0,0 +1,42 @@
+pragma solidity >=0.6.2;
+
+/// @dev Interface of the ERC20 standard as defined in the EIP.
+/// @dev This includes the optional name, symbol, and decimals metadata.
+interface IERC20 {
+    /// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    /// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value`
+    /// is the new allowance.
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+
+    /// @notice Returns the amount of tokens in existence.
+    function totalSupply() external view returns (uint256);
+
+    /// @notice Returns the amount of tokens owned by `account`.
+    function balanceOf(address account) external view returns (uint256);
+
+    /// @notice Moves `amount` tokens from the caller's account to `to`.
+    function transfer(address to, uint256 amount) external returns (bool);
+
+    /// @notice Returns the remaining number of tokens that `spender` is allowed
+    /// to spend on behalf of `owner`
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    /// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
+    /// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    /// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism.
+    /// `amount` is then deducted from the caller's allowance.
+    function transferFrom(address from, address to, uint256 amount) external returns (bool);
+
+    /// @notice Returns the name of the token.
+    function name() external view returns (string memory);
+
+    /// @notice Returns the symbol of the token.
+    function symbol() external view returns (string memory);
+
+    /// @notice Returns the decimals places of the token.
+    function decimals() external view returns (uint8);
+}