test-isol-01 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# test-isol
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/contracts/ERC3009/ERC3009.sol

@@ -0,0 +1,67 @@
+// 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

@@ -0,0 +1,35 @@
+// 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;
+}

package/contracts/adapter/ITransferAuthorize.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @title ITransferAuthorize
+/// @notice Interface for EIP-712 based transfer/receive authorizations (signed approvals)
+/// @dev Events and function signatures used by TransferAuthorize/implementations
+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);
+
+    /// @notice Returns whether a nonce has been used for a given authorizer
+    /// @param authorizer the account that signed the authorization
+    /// @param nonce the nonce to check
+    /// @return true if the nonce was already used/consumed, false otherwise
+    function authorizeState(
+        address authorizer,
+        bytes32 nonce
+    ) external view returns (bool);
+
+    /// @notice Execute a "receive with authorization" - typically the recipient must call this
+    /// @dev See implementation for access constraints (e.g. only `to` may call)
+    function receiveWithAuthorize(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    /// @notice Execute a "transfer with authorization" - typically any relayer may submit
+    function transferWithAuthorize(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    // ++
+    /// @notice Execute a "approve with authorization" - typically any relayer may submit
+    function approveWithSignature(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    /// @notice Standard ERC20 approve
+    // function approve(address spender, uint256 amount) external returns (bool);
+
+    /// @notice Approve with signature (EIP-2612 style)
+    // function approveWithSignature(
+    //     address owner,
+    //     address spender,
+    //     uint256 value,
+    //     uint256 deadline,
+    //     uint8 v,
+    //     bytes32 r,
+    //     bytes32 s
+    // ) external;
+}

package/contracts/adapter/TransferAuthorize.sol

@@ -0,0 +1,97 @@
+// 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";
+
+/// @title TransferAuthorize
+/// @notice Abstract helper implementing EIP-712 verification and nonce tracking for off-chain signed authorizations
+/// @dev Implementations should call `_verify` and `_useAuthorize` before performing state changes
+abstract contract TransferAuthorize is ITransferAuthorize, EIP712 {
+    using ECDSA for bytes32;
+
+    /// @dev mapping to track used nonces per authorizer: authorizer => nonce => used
+    mapping(address => mapping(bytes32 => bool)) private _authorizeState;
+
+    /// @dev EIP-712 type hashes for the two supported authorization structures
+    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)");
+    
+    bytes32 public constant APPROVE_TYPEHASH =
+        keccak256("ApproveWithAuthorize(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)");
+
+    /// @param name EIP-712 domain name
+    /// @param version EIP-712 domain version
+    constructor(string memory name, string memory version) EIP712(name, version) {}
+
+    /// @notice Check whether a nonce has been used for an authorizer
+    /// @param authorizer signer address
+    /// @param nonce nonce value
+    /// @return true if used
+    function authorizeState(address authorizer, bytes32 nonce)
+        public
+        view
+        override
+        returns (bool)
+    {
+        return _authorizeState[authorizer][nonce];
+    }
+
+    /// @dev Mark an authorization (authorizer + nonce) as used. Emits AuthorizeUsed.
+    /// @param authorizer the signer of the authorization
+    /// @param nonce the nonce used in the signed authorization
+    function _useAuthorize(address authorizer, bytes32 nonce) internal {
+        require(!_authorizeState[authorizer][nonce], "TransferAuthorize: authorization already used");
+        _authorizeState[authorizer][nonce] = true;
+        emit AuthorizeUsed(authorizer, nonce);
+    }
+
+    /// @dev Verify an EIP-712 typed signature and return the recovered signer
+    /// @param typehash the type hash for the struct (RECEIVE_TYPEHASH or TRANSFER_TYPEHASH)
+    /// @param from authorizer (the account that signed)
+    /// @param to recipient
+    /// @param value amount
+    /// @param validAfter earliest valid timestamp (inclusive)
+    /// @param validBefore latest valid timestamp (inclusive)
+    /// @param nonce nonce value
+    /// @param v signature v
+    /// @param r signature r
+    /// @param s signature s
+    /// @return signer recovered address
+    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) {
+        // Validate time: require validAfter <= validBefore
+        require(block.timestamp > validAfter, "TransferAuthorize: not yet valid");
+        require(block.timestamp < validBefore, "TransferAuthorize: expired");
+
+        // Hash the struct per EIP-712
+        bytes32 structHash = keccak256(
+            abi.encode(
+                typehash,
+                from,
+                to,
+                value,
+                validAfter,
+                validBefore,
+                nonce
+            )
+        );
+
+        // Recover the signer from the domain-separated digest
+        signer = _hashTypedDataV4(structHash).recover(v, r, s);
+    }
+}

package/contracts/adapter copy/ITransferAuthorize.sol

@@ -0,0 +1,35 @@
+// 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

@@ -0,0 +1,67 @@
+// 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

@@ -0,0 +1,71 @@
+// 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

@@ -0,0 +1,88 @@
+// 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

@@ -0,0 +1,122 @@
+// 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,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external 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 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);
+    }
+
+    /// @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,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external nonReentrant {
+        // Recover signer and validate
+        address signer = _verify(
+            APPROVE_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 approval
+        _approve(from, to, value);
+    }
+}

package/contracts/extensions/erc20/ERC20WrappedWithAuthorize.sol

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,71 @@
+// 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

@@ -0,0 +1,71 @@
+// 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);
+    }
+}

package/contracts/token/ERC20/extensions/ERC20WithAuthorization.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../../../ERC3009/ERC3009.sol";
+
+abstract contract ERC20WithAuthorization is ERC20, ERC3009 {
+    constructor(string memory name, string memory version)
+        ERC3009(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, "ERC20WithAuthorization: caller != payee");
+
+        address signer = _verify(
+            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            v,
+            r,
+            s
+        );
+        require(signer == from, "ERC20WithAuthorization: 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, "ERC20WithAuthorization: invalid signature");
+
+        _useAuthorization(from, nonce);
+        _transfer(from, to, value);
+    }
+}

package/contracts/token/ERC20/extensions/SendWithAuthorization.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../../../ERC3009/ERC3009.sol";
+
+abstract contract SendWithAuthorization is ERC20, ERC3009 {
+    constructor(string memory name, string memory version)
+        ERC3009(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, "ERC20WithAuthorization: caller != payee");
+
+        address signer = _verify(
+            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            v,
+            r,
+            s
+        );
+        require(signer == from, "ERC20WithAuthorization: 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, "ERC20WithAuthorization: invalid signature");
+
+        _useAuthorization(from, nonce);
+        _transfer(from, to, value);
+    }
+}

package/index.ts

@@ -0,0 +1 @@
+console.log("Hello via Bun!");

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "test-isol-01",
+  "version": "0.0.1",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.4.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}