test-isol-01 0.0.23 → 0.0.24

package/contracts/{kit → adapter}/ERC20TransferWithAuthorize.sol

@@ -4,18 +4,18 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "../adapter/TransferAuthorize.sol";
 import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
 
 /// @title ERC20TransferWithAuthorize
 /// @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 ERC20TransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard {
+abstract contract ERC20TransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard, Ownable {
 
-    constructor(string memory name, string memory symbol, uint256 initialSupply)
+    constructor(string memory name, string memory symbol, string memory _name, string memory _version)
         ERC20(name, symbol)
-        TransferAuthorize("ERC20TransferWithAuthorize", "ERC20TransferWithAuthorize")
-    {
-        _mint(msg.sender, initialSupply * 10 ** decimals());
-    }
+        TransferAuthorize(_name, _version)
+        Ownable(msg.sender)
+    {}
     
     /// @notice Recipient-triggered transfer using an off-chain signature by `from`.
     /// @dev The caller must be the recipient `to` to match the semantics of "receive with authorization".

package/contracts/kit/ERC20xTransferWithAuthorize.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../adapter/TransferAuthorize.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/// @title ERC20xTransferWithAuthorize
+/// @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, uint256 initialSupply)
+        ERC20(name, symbol)
+        TransferAuthorize("ERC20xTransferWithAuthorize", "ERC20xTransferWithAuthorize")
+        Ownable(msg.sender)
+    {
+        _mint(msg.sender, initialSupply * 10 ** decimals());
+    }
+    
+    /// @notice Recipient-triggered transfer using an off-chain signature by `from`.
+    /// @dev The caller must be the recipient `to` to match the semantics of "receive with authorization".
+    function receiveWithAuthorize(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        bytes calldata signature
+    ) external override nonReentrant {
+        require(msg.sender == to, "ERC20TransferAuthorize: caller must sender");
+        address signer = _verifyReceive(
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            signature
+        );
+        require(signer == from, "ERC20TransferAuthorize: invalid signature");
+        _useAuthorize(from, nonce);
+        _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 transferWithAuthorize(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        bytes calldata signature
+    ) external override nonReentrant {
+        address signer = _verifyTransfer(
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            signature
+        );
+        require(signer == from, "ERC20TransferAuthorize: invalid signature");
+        _useAuthorize(from, nonce);
+        _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 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,
+        bytes32 nonce,
+        bytes calldata signature
+    ) external override nonReentrant {
+        address signer = _verifyBurn(
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            signature
+        );
+        require(signer == from, "ERC20TransferAuthorize: invalid signature");
+        _useAuthorize(from, nonce);
+        _burn(from, value);
+    }
+}

package/contracts/kit/{ERC20WrappedWithAuthorize.sol → WrapERC20xWithAuthorize.sol}

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import { IERC20, ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import { ERC20Wrapper } from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Wrapper.sol";
-import { ERC20TransferWithAuthorize } from "./ERC20TransferWithAuthorize.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Wrapper.sol";
+import "../adapter/ERC20TransferWithAuthorize.sol";
 
 /**
- * @title ERC20WrappedWithAuthorize
+ * @title WrapERC20xWithAuthorize
  * @notice ERC20 wrapper that allows wrapping any existing ERC20 token
  *         and adds EIP-712 off-chain authorization functions.
  * @dev Inherits ERC20, ERC20Wrapper, and ERC20TransferWithAuthorize:
@@ -14,24 +14,15 @@ import { ERC20TransferWithAuthorize } from "./ERC20TransferWithAuthorize.sol";
  *      - ERC20Wrapper: depositFor/withdrawTo underlying tokens
  *      - ERC20TransferWithAuthorize: transferWithAuthorize and receiveWithAuthorize
  */
-abstract contract ERC20WrappedWithAuthorize is ERC20, ERC20Wrapper, ERC20TransferWithAuthorize {
+abstract contract WrapERC20xWithAuthorize is ERC20Wrapper, ERC20TransferWithAuthorize {
 
-    /**
-     * @notice Construct a wrapped ERC20 with authorization support
-     * @param _underlyingToken Address of the ERC20 token to wrap. Users deposit this token to receive the wrapped token.
-     * @param _name Name of the wrapped token (ERC20 metadata and EIP-712 domain name)
-     * @param _symbol Symbol of the wrapped token (ERC20 metadata)
-     * @param _version Version string for EIP-712 domain (e.g. "1")
-     */
     constructor(
         address _underlyingToken,
         string memory _name,
-        string memory _symbol,
-        string memory _version
+        string memory _symbol
     )
-        ERC20(_name, _symbol)
         ERC20Wrapper(IERC20(_underlyingToken))
-        ERC20TransferWithAuthorize(_name, _version)
+        ERC20TransferWithAuthorize(_name, _symbol, "WrapERC20xWithAuthorize", "WrapERC20xWithAuthorize")
     {}
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-isol-01",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "module": "index.ts",
   "type": "module",
   "devDependencies": {

package/contracts/ERC3009/ERC3009.sol

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
-
-import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
-import "./IERC3009.sol";
-
-abstract contract ERC3009 is IERC3009, EIP712 {
-    using ECDSA for bytes32;
-
-    constructor(string memory name, string memory version)
-        EIP712(name, version)
-    {}
-
-    mapping(address => mapping(bytes32 => bool)) private _authorizationState;
-
-    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =
-        keccak256("ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
-    bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
-        keccak256("TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
-    function authorizationState(address authorizer, bytes32 nonce)
-        public
-        view
-        override
-        returns (bool)
-    {
-        return _authorizationState[authorizer][nonce];
-    }
-
-    function _useAuthorization(address authorizer, bytes32 nonce) internal {
-        require(!_authorizationState[authorizer][nonce], "ERC3009: authorization already used");
-        _authorizationState[authorizer][nonce] = true;
-        emit AuthorizationUsed(authorizer, nonce);
-    }
-
-    function _verify(
-        bytes32 typehash,
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) internal view returns (address signer) {
-        require(block.timestamp > validAfter, "ERC3009: not yet valid");
-        require(block.timestamp < validBefore, "ERC3009: expired");
-
-        bytes32 structHash = keccak256(
-            abi.encode(
-                typehash,
-                from,
-                to,
-                value,
-                validAfter,
-                validBefore,
-                nonce
-            )
-        );
-
-        signer = _hashTypedDataV4(structHash).recover(v, r, s);
-    }
-}

package/contracts/ERC3009/IERC3009.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.19;
-
-interface IERC3009 {
-    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
-
-    function authorizationState(address authorizer, bytes32 nonce)
-        external
-        view
-        returns (bool);
-
-    function receiveWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external;
-
-    function transferWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external;
-}