t-isol 0.0.7 → 0.0.9

package/contracts/ITransferAuthorize.sol

@@ -8,19 +8,13 @@ interface ITransferAuthorize {
     /// @notice Emitted when an authorization (nonce) has been consumed for an authorizer
     /// @param authorizer the account that signed the authorization
     /// @param nonce unique nonce used by the authorization
-    event AuthorizeUsed(address indexed authorizer, bytes32 indexed nonce);
+    event AuthorizeUsed(address authorizer, bytes32 nonce);
 
     /// @notice Emitted when a transfer with authorization is executed
-    event TransferWithAuthorize(address indexed from, address indexed to, uint256 value, uint256 createTime, uint256 expireTime, bytes32 indexed nonce, bytes auth);
-
-    /// @notice Emitted when a transferFrom with authorization is executed
-    event TransferFromWithAuthorize(address indexed from, address indexed to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 indexed nonce);
-    
-    /// @notice Emitted when a approve with authorization is executed
-    event ApproveWithAuthorize(address indexed from, address indexed to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 indexed nonce);
+    event TransferWithAuthorize(address sender, address from, address to, uint256 value, uint256 createTime, uint256 expireTime, bytes32 nonce, bytes auth);
 
     /// @notice Emitted when a burn with authorization is executed
-    event BurnWithAuthorize(address indexed from, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 indexed nonce);
+    event BurnWithAuthorize(address sender, address from, uint256 value, uint256 createTime, uint256 expireTime, bytes32 nonce, bytes auth);
 
     /// @notice Returns whether a nonce has been used for a given authorizer
     /// @param authorizer the account that signed the authorization
@@ -41,30 +35,6 @@ interface ITransferAuthorize {
         bytes32 nonce,
         bytes calldata auth
     ) external;
-    
-    // ++   
-    /// @notice Execute a "transfer with authorization" - typically any relayer may submit
-    function transferFromWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) external;
-
-    // ++
-    /// @notice Execute a "approve with authorization" - typically any relayer may submit
-    function approveWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) external;
 
     /// @notice Execute a "approve with authorization" - typically any relayer may submit
     function burnWithAuthorize(

package/contracts/TransferAuthorize.sol

@@ -17,14 +17,8 @@ abstract contract TransferAuthorize is ITransferAuthorize, EIP712 {
     bytes32 public constant TRANSFER_TYPEHASH =
         keccak256("TransferWithAuthorize(address from,address to,uint256 value,uint256 createTime,uint256 expireTime,bytes32 nonce)");
 
-    bytes32 public constant TRANSFERFROM_TYPEHASH =
-        keccak256("TransferFromWithAuthorize(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
-    bytes32 public constant APPROVE_TYPEHASH =
-        keccak256("ApproveWithAuthorize(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
     bytes32 public constant BURN_TYPEHASH =
-        keccak256("BurnWithAuthorize(address from,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
+        keccak256("BurnWithAuthorize(address from,uint256 value,uint256 createTime,uint256 expireTime,bytes32 nonce)");
 
     /// @param name EIP-712 domain name
     /// @param version EIP-712 domain version
@@ -61,7 +55,7 @@ abstract contract TransferAuthorize is ITransferAuthorize, EIP712 {
         uint256 expireTime,
         bytes32 nonce,
         bytes calldata auth
-    ) internal  returns (address signer) {
+    ) internal returns (address signer) {
         require(block.timestamp >= createTime, "TransferAuthorize: not yet created");
         require(block.timestamp <= expireTime, "TransferAuthorize: not yet expired");
         bytes32 structHash = keccak256(
@@ -76,84 +70,31 @@ abstract contract TransferAuthorize is ITransferAuthorize, EIP712 {
             )
         );
         signer = ECDSA.recover(_hashTypedDataV4(structHash), auth);
-        emit TransferWithAuthorize(from, to, value, createTime, expireTime, nonce, auth);
-    }
-
-    /// @dev Verify an EIP-712 typed signature for TransferFromWithAuthorize and return the recovered signer
-    function _verifyTransferFrom(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) internal view returns (address signer) {
-        require(block.timestamp >= validAfter, "TransferAuthorize: not yet valid");
-        require(block.timestamp <= validBefore, "TransferAuthorize: expired");
-        bytes32 structHash = keccak256(
-            abi.encode(
-                TRANSFERFROM_TYPEHASH,
-                from,
-                to,
-                value,
-                validAfter,
-                validBefore,
-                nonce
-            )
-        );
-        signer = ECDSA.recover(_hashTypedDataV4(structHash), signature);
-    }
-
-    /// @dev Verify an EIP-712 typed signature for ApproveWithAuthorize and return the recovered signer
-    function _verifyApprove(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) internal view returns (address signer) {
-        require(block.timestamp >= validAfter, "TransferAuthorize: not yet valid");
-        require(block.timestamp <= validBefore, "TransferAuthorize: expired");
-        bytes32 structHash = keccak256(
-            abi.encode(
-                APPROVE_TYPEHASH,
-                from,
-                to,
-                value,
-                validAfter,
-                validBefore,
-                nonce
-            )
-        );
-        signer = ECDSA.recover(_hashTypedDataV4(structHash), signature);
+        emit TransferWithAuthorize(msg.sender, from, to, value, createTime, expireTime, nonce, auth);
     }
 
-    /// @dev Verify an EIP-712 typed signature for BurnWithAuthorize and return the recovered signer
+    /// @dev Verify an EIP-712 typed signature (auth) for BurnWithAuthorize and return the recovered signer
     function _verifyBurn(
         address from,
-        // address to,
         uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
+        uint256 createTime,
+        uint256 expireTime,
         bytes32 nonce,
-        bytes calldata signature
-    ) internal view returns (address signer) {
-        require(block.timestamp >= validAfter, "TransferAuthorize: not yet valid");
-        require(block.timestamp <= validBefore, "TransferAuthorize: expired");
+        bytes calldata auth
+    ) internal returns (address signer) {
+        require(block.timestamp >= createTime, "TransferAuthorize: not yet valid");
+        require(block.timestamp <= expireTime, "TransferAuthorize: expired");
         bytes32 structHash = keccak256(
             abi.encode(
                 BURN_TYPEHASH,
                 from,
-                // to,
                 value,
-                validAfter,
-                validBefore,
+                createTime,
+                expireTime,
                 nonce
             )
         );
-        signer = ECDSA.recover(_hashTypedDataV4(structHash), signature);
+        signer = ECDSA.recover(_hashTypedDataV4(structHash), auth);
+        emit BurnWithAuthorize(msg.sender, from, value, createTime, expireTime, nonce, auth);
     }
 }

package/contracts/kit/ERC20xTransferWithAuthorize.sol

@@ -10,7 +10,6 @@ import "@openzeppelin/contracts/access/Ownable.sol";
 /// @notice ERC20 extension that supports EIP-712 based `transferWithAuthorize` and `receiveWithAuthorize` flows
 /// @dev `receiveWithAuthorize` restricts the caller to the `to` address (recipient submits the proof). `transferWithAuthorize` is open to relayers.
 abstract contract ERC20xTransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard, Ownable {
-
     constructor(
         string memory name,
         string memory symbol,
@@ -45,84 +44,30 @@ abstract contract ERC20xTransferWithAuthorize is ERC20, TransferAuthorize, Reent
             nonce,
             auth
         );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
+        require(signer == from, "transferWithAuthorize: invalid signature");
         _useAuthorize(from, nonce);
         _transfer(from, to, value);
-        // emit TransferWithAuthorize(from, to, value, createTime, expireTime, nonce, auth);
-    }
-
-    /// @notice Relayer-triggered transfer using an off-chain signature by `from`.
-    /// @dev This allows anyone (a relayer) to submit the signed authorization on-chain.
-    function transferFromWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) external override nonReentrant {
-        address signer = _verifyTransferFrom(
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            signature
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-        _useAuthorize(from, nonce);
-        _spendAllowance(from, to, value);
-        _transfer(from, to, value);
-    }
-
-    /// @notice Relayer-triggered transfer using an off-chain signature by `from`.
-    /// @dev This allows anyone (a relayer) to submit the signed authorization on-chain.
-    function approveWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        bytes calldata signature
-    ) external override nonReentrant {
-        address signer = _verifyApprove(
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            signature
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-        _useAuthorize(from, nonce);
-        _approve(from, to, value);
     }
 
     /// @notice Relayer-triggered transfer using an off-chain signature by `from`.
     /// @dev This allows anyone (a relayer) to submit the signed authorization on-chain.
     function burnWithAuthorize(
         address from,
-        // address to,
         uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
+        uint256 createTime,
+        uint256 expireTime,
         bytes32 nonce,
-        bytes calldata signature
+        bytes calldata auth
     ) external override nonReentrant {
         address signer = _verifyBurn(
             from,
-            // to,
             value,
-            validAfter,
-            validBefore,
+            createTime,
+            expireTime,
             nonce,
-            signature
+            auth
         );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
+        require(signer == from, "burnWithAuthorize: invalid signature");
         _useAuthorize(from, nonce);
         _burn(from, value);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t-isol",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "module": "index.ts",
   "type": "module",
   "devDependencies": {