Merge pull request #7 from violetprotocol/dev

v0.2.0-rc

contracts/AuthCompatible.sol → contracts/AccessTokenConsumer.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
+pragma solidity >=0.8.13;
 
 import "hardhat/console.sol";
-import "./IAuthVerifier.sol";
+import "./IAccessTokenVerifier.sol";
 
-contract AuthCompatible {
-    IAuthVerifier private _verifier;
+contract AccessTokenConsumer {
+    IAccessTokenVerifier private _verifier;
 
-    constructor(address authVerifier) {
-        _verifier = IAuthVerifier(authVerifier);
+    constructor(address accessTokenVerifier) {
+        _verifier = IAccessTokenVerifier(accessTokenVerifier);
     }
 
     modifier requiresAuth(
@@ -17,7 +17,7 @@ contract AuthCompatible {
         bytes32 s,
         uint256 expiry
     ) {
-        require(verify(v, r, s, expiry), "AuthToken: verification failure");
+        require(verify(v, r, s, expiry), "AccessToken: verification failure");
         _;
     }
 
@@ -27,11 +27,11 @@ contract AuthCompatible {
         bytes32 s,
         uint256 expiry
     ) internal view returns (bool) {
-        AuthToken memory token = constructToken(expiry);
+        AccessToken memory token = constructToken(expiry);
         return _verifier.verify(token, v, r, s);
     }
 
-    function constructToken(uint256 expiry) internal view returns (AuthToken memory token) {
+    function constructToken(uint256 expiry) internal view returns (AccessToken memory token) {
         FunctionCall memory functionCall;
         functionCall.functionSignature = msg.sig;
         functionCall.target = address(this);
@@ -55,9 +55,8 @@ contract AuthCompatible {
             let endOfSigExp := add(startPos, 0x80)
             let totalInputSize := sub(calldatasize(), endOfSigExp)
 
-            // disgusting dirty putrid abomination of a detestable drivelous hack because
-            // for some reason byte array pointers are being assigned the same address as another causing overwrite
-            inputs := add(inputs, mul(calldatasize(), 2))
+            // Overwrite data to calldata pointer
+            inputs := ptr
 
             // Store expected length of total byte array as first value
             mstore(inputs, totalInputSize)

contracts/AuthVerifier.sol → contracts/AccessTokenVerifier.sol

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
+pragma solidity >=0.8.13;
 
-import "./IAuthVerifier.sol";
+import "./IAccessTokenVerifier.sol";
 import "./KeyInfrastructure.sol";
 
-contract AuthVerifier is IAuthVerifier, KeyInfrastructure {
+contract AccessTokenVerifier is IAccessTokenVerifier, KeyInfrastructure {
     bytes32 private constant EIP712DOMAIN_TYPEHASH =
         keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
 
@@ -15,7 +15,7 @@ contract AuthVerifier is IAuthVerifier, KeyInfrastructure {
     // solhint-disable max-line-length
     bytes32 private constant TOKEN_TYPEHASH =
         keccak256(
-            "AuthToken(uint256 expiry,FunctionCall functionCall)FunctionCall(bytes4 functionSignature,address target,address caller,bytes parameters)"
+            "AccessToken(uint256 expiry,FunctionCall functionCall)FunctionCall(bytes4 functionSignature,address target,address caller,bytes parameters)"
         );
 
     // solhint-disable var-name-mixedcase
@@ -58,19 +58,19 @@ contract AuthVerifier is IAuthVerifier, KeyInfrastructure {
             );
     }
 
-    function hash(AuthToken memory token) internal pure returns (bytes32) {
+    function hash(AccessToken memory token) internal pure returns (bytes32) {
         return keccak256(abi.encode(TOKEN_TYPEHASH, token.expiry, hash(token.functionCall)));
     }
 
     function verify(
-        AuthToken memory token,
+        AccessToken memory token,
         uint8 v,
         bytes32 r,
         bytes32 s
     ) public view override returns (bool) {
         bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash(token)));
 
-        require(token.expiry > block.timestamp, "AuthToken: has expired");
+        require(token.expiry > block.timestamp, "AccessToken: has expired");
         return ecrecover(digest, v, r, s) == _issuer;
     }
 }

contracts/IAuthVerifier.sol → contracts/IAccessTokenVerifier.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
+pragma solidity >=0.8.13;
 
 struct EIP712Domain {
     string name;
@@ -22,14 +22,14 @@ struct FunctionCall {
     // FunctionParam[] parameters; // array of input parameters to the function call
 }
 
-struct AuthToken {
+struct AccessToken {
     uint256 expiry;
     FunctionCall functionCall;
 }
 
-interface IAuthVerifier {
+interface IAccessTokenVerifier {
     function verify(
-        AuthToken memory token,
+        AccessToken memory token,
         uint8 v,
         bytes32 r,
         bytes32 s

contracts/KeyInfrastructure.sol

@@ -1,5 +1,5 @@
 //SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity >=0.8.13;
 
 contract KeyInfrastructure {
     address internal _root;

contracts/DummyDapp.sol → contracts/examples/DummyDapp.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.4;
+pragma solidity >=0.8.13;
 
 import "hardhat/console.sol";
-import "./AuthCompatible.sol";
+import "../AccessTokenConsumer.sol";
 
-contract DummyDapp is AuthCompatible {
-    constructor(address verifier) AuthCompatible(verifier) {}
+contract DummyDapp is AccessTokenConsumer {
+    constructor(address verifier) AccessTokenConsumer(verifier) {}
 
     function lend(
         uint8 v,

contracts/mocks/ConsumerMock.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.13;
+
+import "hardhat/console.sol";
+import "../AccessTokenConsumer.sol";
+
+contract ConsumerMock is AccessTokenConsumer {
+    constructor(address verifier) AccessTokenConsumer(verifier) {}
+
+    function noParams(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleAddress(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        address addr
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleUint256(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        uint256 num
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleStringCalldata(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleStringMemory(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string memory str
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleByte(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        bytes1 b1
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleBytesCalldata(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        bytes calldata b1
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function singleBytesMemory(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        bytes memory b1
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function doubleAddressUint(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        address addr,
+        uint256 num
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function doubleUint256String(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        uint256 num,
+        string memory str
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function doubleStringBytesCalldata(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str,
+        bytes calldata b
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function doubleStringBytesMemory(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str,
+        bytes calldata b
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function multipleStringBytesAddress(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str,
+        bytes calldata b,
+        address addr
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function multipleStringBytesAddressUint256(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str,
+        bytes calldata b,
+        address addr,
+        uint256 num
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+
+    function multipleStringBytesAddressUint256Bytes(
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        uint256 expiry,
+        string calldata str,
+        bytes calldata b,
+        address addr,
+        uint256 num,
+        bytes calldata b2
+    ) public view requiresAuth(v, r, s, expiry) returns (bool) {
+        return true;
+    }
+}