feat: upgrade to solc 0.6.10 and added GsnCapableDocumentStore (#76)

* feat: upgrade solidity 0.6.10

* feat: added upgradeSafe contracts

* feat: added gsn capable document store

* fix: using wrong compiler and removed proxy factory test

* chore: upgrade solhint and fix lint

* chore: updated tsc to not compile node_modules/@types/*.d.ts files

* feat: added gsn capable class

* feat: added test for new contracts

* fix: added addition test from comments

* fix: patch bytecode (#77)

* fix: bytecode

* fix: refactored data

* fix: lint

Co-authored-by: Raymond Yeh <ray@geek.sg>

Co-authored-by: yehjxraymond <yehjxraymond@gmail.com>
Co-authored-by: Raymond Yeh <ray@geek.sg>

Author: justussoh

.gitignore

@@ -4,6 +4,7 @@ yarn-error.log
 .env
 *.iml
 .idea
+/.vscode
 /src/contracts
 /dist
 /build

.solhint.json

@@ -2,6 +2,9 @@
   "extends": ["solhint:recommended"],
   "plugins": ["prettier"],
   "rules": {
-    "indent": ["error", 2]
+    "compiler-version": ["error", "^0.6.10"],
+    "func-name-mixedcase": "off",
+    "no-empty-blocks": "off",
+    "reason-string": ["warn", {"maxLength": 256}]
   }
 }

contracts/Context.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.6.10;
+
+/*
+ * @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 GSN 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.
+ */
+contract Context {
+  function _msgSender() internal view virtual returns (address payable) {
+    return msg.sender;
+  }
+
+  function _msgData() internal view virtual returns (bytes memory) {
+    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+    return msg.data;
+  }
+}

contracts/ContextUpgradeSafe.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.6.10;
+
+import "./Initializable.sol";
+
+/*
+ * @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 GSN 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.
+ */
+contract ContextUpgradeSafe is Initializable {
+  // Empty internal constructor, to prevent people from mistakenly deploying
+  // an instance of this contract, which should be used via inheritance.
+
+  function __Context_init() internal initializer {
+    __Context_init_unchained();
+  }
+
+  function __Context_init_unchained() internal initializer {}
+
+  function _msgSender() internal view virtual returns (address payable) {
+    return msg.sender;
+  }
+
+  function _msgData() internal view virtual returns (bytes memory) {
+    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+    return msg.data;
+  }
+
+  uint256[50] private __gap;
+}

contracts/DocumentStore.sol

@@ -1,4 +1,6 @@
-pragma solidity ^0.5.16;
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.6.10;
 
 import "./Ownable.sol";
 

contracts/DocumentStoreCreator.sol

@@ -1,4 +1,6 @@
-pragma solidity 0.5.16;
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.6.10;
 
 import "./UpgradableDocumentStore.sol";
 

contracts/DocumentStoreWithRevokeReasons.sol

@@ -1,4 +1,6 @@
-pragma solidity 0.5.16;
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.6.10;
 
 import "./UpgradableDocumentStore.sol";
 

contracts/GsnCapable.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.6.10;
+
+import "./Ownable.sol";
+
+// File: contracts/introspection/IERC165.sol
+
+/*
+ * @dev Interface of the ERC165 standard, as defined in the
+ * https://eips.ethereum.org/EIPS/eip-165[EIP].
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others ({ERC165Checker}).
+ *
+ * For an implementation, see {ERC165}.
+ */
+interface IERC165 {
+  /**
+   * @dev Returns true if this contract implements the interface defined by
+   * `interfaceId`. See the corresponding
+   * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+   * to learn more about how these ids are created.
+   *
+   * This function call must use less than 30 000 gas.
+   */
+  function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+// File: contracts/introspection/ERC165.sol
+
+/**
+ * @dev Implementation of the {IERC165} interface.
+ *
+ * Contracts may inherit from this and call {_registerInterface} to declare
+ * their support of an interface.
+ */
+contract ERC165 is IERC165 {
+  /*
+   * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
+   */
+  bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
+
+  /**
+   * @dev Mapping of interface ids to whether or not it's supported.
+   */
+  mapping(bytes4 => bool) private _supportedInterfaces;
+
+  constructor() internal {
+    // Derived contracts need only register support for their own interfaces,
+    // we register support for ERC165 itself here
+    _registerInterface(_INTERFACE_ID_ERC165);
+  }
+
+  /**
+   * @dev See {IERC165-supportsInterface}.
+   *
+   * Time complexity O(1), guaranteed to always use less than 30 000 gas.
+   */
+  function supportsInterface(bytes4 interfaceId) external override view returns (bool) {
+    return _supportedInterfaces[interfaceId];
+  }
+
+  /**
+   * @dev Registers the contract as an implementer of the interface defined by
+   * `interfaceId`. Support of the actual ERC165 interface is automatic and
+   * registering its interface id is not required.
+   *
+   * See {IERC165-supportsInterface}.
+   *
+   * Requirements:
+   *
+   * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
+   */
+  function _registerInterface(bytes4 interfaceId) internal {
+    require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
+    _supportedInterfaces[interfaceId] = true;
+  }
+}
+
+contract GsnCapable is ERC165, Ownable {
+  address public paymaster;
+  bytes4 private constant _INTERFACE_ID_GSN_CAPABLE = 0xa5a23640;
+
+  event PaymasterSet(address indexed target);
+
+  constructor() public {
+    // register the supported interface to conform to TradeTrustERC721 via ERC165
+    _registerInterface(_INTERFACE_ID_GSN_CAPABLE);
+  }
+
+  function setPaymaster(address target) external onlyOwner {
+    paymaster = target;
+    emit PaymasterSet(target);
+  }
+
+  function getPaymaster() external view returns (address) {
+    return paymaster;
+  }
+}
+
+contract calculateGsnCapableSelector {
+  function calculateSelector() public pure returns (bytes4) {
+    GsnCapable i;
+    return i.setPaymaster.selector ^ i.getPaymaster.selector;
+  }
+}

contracts/GsnCapableDocumentStore.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.6.10;
+
+import "./Ownable.sol";
+import "./DocumentStore.sol";
+import "./GsnCapable.sol";
+import "@opengsn/gsn/contracts/BaseRelayRecipient.sol";
+import "@opengsn/gsn/contracts/interfaces/IKnowForwarderAddress.sol";
+
+contract GsnCapableDocumentStore is DocumentStore, BaseRelayRecipient, IKnowForwarderAddress, GsnCapable {
+  constructor(string memory _name, address _forwarder) public DocumentStore(_name) {
+    trustedForwarder = _forwarder;
+  }
+
+  function _msgSender() internal override(Context, BaseRelayRecipient) view returns (address payable) {
+    return BaseRelayRecipient._msgSender();
+  }
+
+  function _msgData() internal override(Context, BaseRelayRecipient) view returns (bytes memory) {
+    return BaseRelayRecipient._msgData();
+  }
+
+  function getTrustedForwarder() public override view returns (address) {
+    return trustedForwarder;
+  }
+
+  function setTrustedForwarder(address _forwarder) public onlyOwner {
+    trustedForwarder = _forwarder;
+  }
+
+  function versionRecipient() external virtual override view returns (string memory) {
+    return version;
+  }
+}

contracts/Initializable.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.6.10;
+
+/**
+ * @title Initializable
+ *
+ * @dev Helper contract to support initializer functions. To use it, replace
+ * the constructor with a function that has the `initializer` modifier.
+ * WARNING: Unlike constructors, initializer functions must be manually
+ * invoked. This applies both to deploying an Initializable contract, as well
+ * as extending an Initializable contract via inheritance.
+ * WARNING: When used with inheritance, manual care must be taken to not invoke
+ * a parent initializer twice, or ensure that all initializers are idempotent,
+ * because this is not dealt with automatically as with constructors.
+ */
+contract Initializable {
+  /**
+   * @dev Indicates that the contract has been initialized.
+   */
+  bool private initialized;
+
+  /**
+   * @dev Indicates that the contract is in the process of being initialized.
+   */
+  bool private initializing;
+
+  /**
+   * @dev Modifier to use in the initializer function of a contract.
+   */
+  modifier initializer() {
+    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
+
+    bool isTopLevelCall = !initializing;
+    if (isTopLevelCall) {
+      initializing = true;
+      initialized = true;
+    }
+
+    _;
+
+    if (isTopLevelCall) {
+      initializing = false;
+    }
+  }
+
+  /// @dev Returns true if and only if the function is running in the constructor
+  function isConstructor() private view returns (bool) {
+    // extcodesize checks the size of the code stored in an address, and
+    // address returns the current address. Since the code is still not
+    // deployed when running a constructor, any checks on its code size will
+    // yield zero, making it an effective way to detect if a contract is
+    // under construction or not.
+    address self = address(this);
+    uint256 cs;
+    assembly {
+      cs := extcodesize(self)
+    }
+    return cs == 0;
+  }
+
+  // Reserved storage space to allow for layout changes in the future.
+  uint256[50] private ______gap;
+}