test-isol-01 0.0.21 → 0.0.23

package/contracts/kit/ERC20TransferWithAuthorize.sol

@@ -9,11 +9,13 @@ import "@openzeppelin/contracts/utils/ReentrancyGuard.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 ERC20TransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard {
-    /// @param name EIP-712 domain name
-    /// @param version EIP-712 domain version
-    constructor(string memory name, string memory version)
-        TransferAuthorize(name, version)
-    {}
+
+    constructor(string memory name, string memory symbol, uint256 initialSupply)
+        ERC20(name, symbol)
+        TransferAuthorize("ERC20TransferWithAuthorize", "ERC20TransferWithAuthorize")
+    {
+        _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".

package/package.json

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

package/contracts/adapter copy/ITransferAuthorize.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-interface ITransferAuthorize {
-    event AuthorizeUsed(address indexed authorizer, bytes32 indexed nonce);
-
-    function authorizeState(address authorizer, bytes32 nonce)
-        external
-        view
-        returns (bool);
-
-    function receiveWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external;
-
-    function transferWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external;
-}

package/contracts/adapter copy/TransferAuthorize.sol

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
-import "./ITransferAuthorize.sol";
-
-abstract contract TransferAuthorize is ITransferAuthorize, EIP712 {
-    using ECDSA for bytes32;
-
-    constructor(string memory name, string memory version)
-        EIP712(name, version)
-    {}
-
-    mapping(address => mapping(bytes32 => bool)) private _authorizeState;
-
-    bytes32 public constant RECEIVE_TYPEHASH =
-        keccak256("ReceiveWithAuthorize(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
-    bytes32 public constant TRANSFER_TYPEHASH =
-        keccak256("TransferWithAuthorize(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
-
-    function authorizeState(address authorizer, bytes32 nonce)
-        public
-        view
-        override
-        returns (bool)
-    {
-        return _authorizeState[authorizer][nonce];
-    }
-
-    function _useAuthorize(address authorizer, bytes32 nonce) internal {
-        require(!_authorizeState[authorizer][nonce], "TransferAuthorize: authorization already used");
-        _authorizeState[authorizer][nonce] = true;
-        emit AuthorizeUsed(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, "TransferAuthorize: not yet valid");
-        require(block.timestamp <= validBefore, "TransferAuthorize: expired");
-
-        bytes32 structHash = keccak256(
-            abi.encode(
-                typehash,
-                from,
-                to,
-                value,
-                validAfter,
-                validBefore,
-                nonce
-            )
-        );
-
-        signer = _hashTypedDataV4(structHash).recover(v, r, s);
-    }
-}

package/contracts/extensions/ERC20TransferAuth.sol

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import ".././adapter/TransferAuth.sol";
-
-abstract contract ERC20TransferAuth is ERC20, TransferAuth {
-    constructor(string memory name, string memory version)
-        TransferAuth(name, version)
-    {}
-    
-    function receiveWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        require(msg.sender == to, "ERC20TransferAuth: caller != payee");
-
-        address signer = _verify(
-            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuth: invalid signature");
-
-        _useAuthorization(from, nonce);
-        _transfer(from, to, value);
-    }
-
-    function transferWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        address signer = _verify(
-            TRANSFER_WITH_AUTHORIZATION_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuth: invalid signature");
-
-        _useAuthorization(from, nonce);
-        _transfer(from, to, value);
-    }
-}

package/contracts/extensions/TransferWithAuthorize.sol

@@ -1,88 +0,0 @@
-// 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";
-
-/// @title TransferWithAuthorize
-/// @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 TransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard {
-    /// @param name EIP-712 domain name
-    /// @param version EIP-712 domain version
-    constructor(string memory name, string memory version)
-        TransferAuthorize(name, version)
-    {}
-    
-    /// @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,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override nonReentrant {
-        // Only the recipient should be able to call this helper
-        require(msg.sender == to, "ERC20TransferAuthorize: caller must sender");
-
-        // Recover signer and validate
-        address signer = _verify(
-            RECEIVE_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-
-        // Mark nonce as used
-        _useAuthorize(from, nonce);
-        // Execute the token transfer
-        _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,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override nonReentrant {
-        // Recover signer and validate
-        address signer = _verify(
-            TRANSFER_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-
-        // Mark nonce as used
-        _useAuthorize(from, nonce);
-        // Execute the token transfer
-        _transfer(from, to, value);
-    }
-}

package/contracts/extensions/erc20/ERC20TransferWithAuthorize.sol

@@ -1,144 +0,0 @@
-// 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";
-
-/// @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 {
-    /// @param name EIP-712 domain name
-    /// @param version EIP-712 domain version
-    constructor(string memory name, string memory version)
-        TransferAuthorize(name, version)
-    {}
-    
-    /// @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/extensions/erc20/ERC20WrappedWithAuthorize.sol

@@ -1,51 +0,0 @@
-// 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";
-
-/**
- * @title ERC20WrappedWithAuthorize
- * @notice ERC20 wrapper that allows wrapping any existing ERC20 token
- *         and adds EIP-712 off-chain authorization functions.
- * @dev Inherits ERC20, ERC20Wrapper, and ERC20TransferWithAuthorize:
- *      - ERC20: standard token functionality
- *      - ERC20Wrapper: depositFor/withdrawTo underlying tokens
- *      - ERC20TransferWithAuthorize: transferWithAuthorize and receiveWithAuthorize
- */
-abstract contract ERC20WrappedWithAuthorize is ERC20, 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
-    )
-        ERC20(_name, _symbol)
-        ERC20Wrapper(IERC20(_underlyingToken))
-        ERC20TransferWithAuthorize(_name, _version)
-    {}
-
-    /**
-     * @notice Returns the token decimals
-     * @dev Overrides both ERC20 and ERC20Wrapper decimals function
-     * @return uint8 decimals of the token (usually matches underlying token)
-     */
-    function decimals()
-        public
-        view
-        virtual
-        override(ERC20, ERC20Wrapper)
-        returns (uint8)
-    {
-        return super.decimals();
-    }
-}

package/contracts/extensions copy/ERC20TransferAuth.sol

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import ".././adapter/TransferAuth.sol";
-
-abstract contract ERC20TransferAuth is ERC20, TransferAuth {
-    constructor(string memory name, string memory version)
-        TransferAuth(name, version)
-    {}
-    
-    function receiveWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        require(msg.sender == to, "ERC20TransferAuth: caller != payee");
-
-        address signer = _verify(
-            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuth: invalid signature");
-
-        _useAuthorization(from, nonce);
-        _transfer(from, to, value);
-    }
-
-    function transferWithAuthorization(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        address signer = _verify(
-            TRANSFER_WITH_AUTHORIZATION_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuth: invalid signature");
-
-        _useAuthorization(from, nonce);
-        _transfer(from, to, value);
-    }
-}

package/contracts/extensions copy/erc20/ERC20TransferWithAuthorize.sol

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
-import "../../adapter/TransferAuthorize.sol";
-
-abstract contract ERC20TransferWithAuthorize is ERC20, TransferAuthorize {
-    constructor(string memory name, string memory version)
-        TransferAuthorize(name, version)
-    {}
-    
-    function receiveWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        require(msg.sender == to, "ERC20TransferAuthorize: caller must sender");
-
-        address signer = _verify(
-            RECEIVE_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-
-        _useAuthorize(from, nonce);
-        _transfer(from, to, value);
-    }
-
-    function transferWithAuthorize(
-        address from,
-        address to,
-        uint256 value,
-        uint256 validAfter,
-        uint256 validBefore,
-        bytes32 nonce,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) external override {
-        address signer = _verify(
-            TRANSFER_TYPEHASH,
-            from,
-            to,
-            value,
-            validAfter,
-            validBefore,
-            nonce,
-            v,
-            r,
-            s
-        );
-        require(signer == from, "ERC20TransferAuthorize: invalid signature");
-
-        _useAuthorize(from, nonce);
-        _transfer(from, to, value);
-    }
-}