t-isol 0.0.9 → 0.0.10

package/contracts/base/BasexERC20.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @title BasexERC20 (Base)
+ * @notice Provides a simple and efficient way to deploy your own ERC20 token with custom parameters, saving time and reducing errors.
+ * @dev Inherit this contract to quickly deploy an ERC20 token using OpenZeppelin's implementation.
+ *      Set name, symbol, and initial supply via constructor. Mints all supply to deployer.
+ *
+ * Arguments:
+ * - name (string): Token name
+ * - symbol (string): Token symbol
+ * - initialSupply (uint256): Initial token supply (Integer number)
+ *
+ * Example:
+ * contract MyToken is BasexERC20 {
+ *     constructor() 
+ *         BasexERC20(
+ *          "MyToken", 
+ *          "MTK", 
+ *          1000000 // 1 million tokens
+ *         ) 
+ *     {}
+ * }
+ */
+abstract contract BasexERC20 is ERC20 {
+    constructor(
+        string memory name, 
+        string memory symbol, 
+        uint256 initialSupply
+    )
+        ERC20(name, symbol)
+    {
+        _mint(msg.sender, initialSupply * 10 ** decimals());
+    }
+}

package/contracts/kit/ERC20WrappedxWithAuthorize.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Wrapper.sol";
+import "../TransferAuthorize.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title ERC20WrappedxWithAuthorize (Kit)
+ * @notice ERC20 wrapper with EIP-712 based off-chain authorized transfers and burns.
+ * @dev Wraps an existing ERC20 token, adding `transferWithAuthorize` and `burnWithAuthorize` functions.
+ *      Enables gasless transfers and advanced flows using signatures. Integrates OpenZeppelin ERC20Wrapper, ReentrancyGuard, and Ownable.
+ *
+ * Arguments:
+ * - underlyingToken (address): Address of the underlying ERC20 token to wrap
+ * - name (string): Token name
+ * - symbol (string): Token symbol
+ * - domainName (string): EIP-712 domain name
+ * - domainVersion (string): EIP-712 domain version
+ *
+ * Example:
+ * contract MyWrappedToken is ERC20WrappedxWithAuthorize {
+ *     constructor() 
+ *         ERC20WrappedxWithAuthorize(
+ *          0x123...abc, // underlying token address
+ *          "MyWrappedToken", 
+ *          "MWTK", 
+ *          "MyWrappedToken",
+ *          "1"
+ *         ) 
+ *     {}
+ * }
+ */
+abstract contract ERC20WrappedxWithAuthorize is ERC20, ERC20Wrapper, TransferAuthorize, ReentrancyGuard, Ownable {
+    constructor(
+        address _underlyingToken,
+        string memory _name,
+        string memory _symbol,
+        string memory _domainName,
+        string memory _domainVersion
+    )
+        ERC20(_name, _symbol)
+        ERC20Wrapper(IERC20(_underlyingToken))
+        TransferAuthorize(_domainName, _domainVersion)
+        Ownable(msg.sender)
+    {}
+
+    /**
+     * @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();
+    }
+
+    /// @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 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyTransfer(
+            from,
+            to,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        require(signer == from, "transferWithAuthorize: 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 burnWithAuthorize(
+        address from,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyBurn(
+            from,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        require(signer == from, "burnWithAuthorize: invalid signature");
+        _useAuthorize(from, nonce);
+        _burn(from, value);
+    }
+}

package/contracts/kit/ERC20xTransferWithAuthorize.sol

@@ -6,9 +6,32 @@ import "../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.
+/**
+ * @title ERC20xTransferWithAuthorize (Kit)
+ * @notice ERC20 extension for fast, secure, and flexible off-chain authorized transfers and burns (EIP-712).
+ * @dev Adds `transferWithAuthorize` and `burnWithAuthorize` for meta-transactions and relayer support.
+ *      Enables gasless transfers and advanced flows using signatures. Integrates OpenZeppelin ERC20, ReentrancyGuard, and Ownable.
+ *
+ * Arguments:
+ * - name (string): Token name
+ * - symbol (string): Token symbol
+ * - initialSupply (uint256): Initial token supply (Integer number)
+ * - domainName (string): EIP-712 domain name
+ * - domainVersion (string): EIP-712 domain version
+ *
+ * Example:
+ * contract MyToken is ERC20xTransferWithAuthorize {
+ *     constructor() 
+ *         ERC20xTransferWithAuthorize(
+ *          "MyToken", 
+ *          "MTK", 
+ *          1000000, // 1 million tokens
+ *          "MyToken",
+ *          "1"
+ *         ) 
+ *     {}
+ * }
+ */
 abstract contract ERC20xTransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard, Ownable {
     constructor(
         string memory name,

package/contracts/kit/KitxERC20.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title KitxERC20 (Kit)
+ * @notice Fast ERC20 foundation with burnable and ownable features for rapid token creation.
+ * @dev Inherit to quickly deploy a custom ERC20 token with burn and ownership control.
+ *      Set name, symbol, and initial supply via constructor. Mints all supply to deployer.
+ *
+ * Arguments:
+ * - name (string): Token name
+ * - symbol (string): Token symbol
+ * - initialSupply (uint256): Initial token supply (Integer number)
+ *
+ * Example:
+ * contract MyToken is KitxERC20 {
+ *     constructor() 
+ *         KitxERC20(
+ *          "MyToken", 
+ *          "MTK", 
+ *          1000000 // 1 million tokens
+ *         ) 
+ *     {}
+ * }
+ */
+abstract contract KitxERC20 is ERC20, ERC20Burnable, Ownable {
+    constructor(
+        string memory name, 
+        string memory symbol, 
+        uint256 initialSupply
+    )
+        ERC20(name, symbol)
+        Ownable(msg.sender)
+    {
+        _mint(msg.sender, initialSupply * 10 ** decimals());
+    }
+}

package/contracts/modular/ERC20xTransferWithAuthorize.sol

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../TransferAuthorize.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+
+/**
+ * @title ERC20xTransferWithAuthorize (Modular)
+ * @notice ERC20 extension for modular, off-chain authorized transfers and burns (EIP-712).
+ * @dev Adds `transferWithAuthorize` and `burnWithAuthorize` for meta-transactions and relayer support.
+ *      Enables gasless transfers and advanced flows using signatures. Integrates OpenZeppelin ERC20 and ReentrancyGuard.
+ *
+ * Arguments:
+ * - domainName (string): EIP-712 domain name
+ * - domainVersion (string): EIP-712 domain version
+ *
+ * Example:
+ * contract MyToken is ERC20xTransferWithAuthorize {
+ *     constructor() 
+ *         ERC20xTransferWithAuthorize(
+ *          "MyToken",
+ *          "1"
+ *         ) 
+ *     {}
+ * }
+ */
+abstract contract ERC20xTransferWithAuthorize is ERC20, TransferAuthorize, ReentrancyGuard {
+    constructor(
+        string memory domainName,
+        string memory domainVersion
+    )
+        TransferAuthorize(domainName, domainVersion)
+    {}
+
+    /// @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 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyTransfer(
+            from,
+            to,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        require(signer == from, "transferWithAuthorize: 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 burnWithAuthorize(
+        address from,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyBurn(
+            from,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        require(signer == from, "burnWithAuthorize: invalid signature");
+        _useAuthorize(from, nonce);
+        _burn(from, value);
+    }
+}

package/contracts copy/ITransferAuthorize.sol

@@ -0,0 +1,49 @@
+// 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 authorizer, bytes32 nonce);
+
+    /// @notice Emitted when a transfer with authorization is executed
+    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 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
+    /// @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 "transfer with authorization" - typically any relayer may submit
+    function transferWithAuthorize(
+        address from,
+        address to,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external;
+
+    /// @notice Execute a "approve with authorization" - typically any relayer may submit
+    function burnWithAuthorize(
+        address from,
+        // address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        bytes calldata signature
+    ) external;
+}

package/contracts copy/TransferAuthorize.sol

@@ -0,0 +1,100 @@
+// 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;
+
+    bytes32 public constant TRANSFER_TYPEHASH =
+        keccak256("TransferWithAuthorize(address from,address to,uint256 value,uint256 createTime,uint256 expireTime,bytes32 nonce)");
+
+    bytes32 public constant BURN_TYPEHASH =
+        keccak256("BurnWithAuthorize(address from,uint256 value,uint256 createTime,uint256 expireTime,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 (auth) for TransferWithAuthorize and return the recovered signer
+    function _verifyTransfer(
+        address from,
+        address to,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) internal returns (address signer) {
+        require(block.timestamp >= createTime, "TransferAuthorize: not yet created");
+        require(block.timestamp <= expireTime, "TransferAuthorize: not yet expired");
+        bytes32 structHash = keccak256(
+            abi.encode(
+                TRANSFER_TYPEHASH,
+                from,
+                to,
+                value,
+                createTime,
+                expireTime,
+                nonce
+            )
+        );
+        signer = ECDSA.recover(_hashTypedDataV4(structHash), auth);
+        emit TransferWithAuthorize(msg.sender, from, to, value, createTime, expireTime, nonce, auth);
+    }
+
+    /// @dev Verify an EIP-712 typed signature (auth) for BurnWithAuthorize and return the recovered signer
+    function _verifyBurn(
+        address from,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        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,
+                value,
+                createTime,
+                expireTime,
+                nonce
+            )
+        );
+        signer = ECDSA.recover(_hashTypedDataV4(structHash), auth);
+        emit BurnWithAuthorize(msg.sender, from, value, createTime, expireTime, nonce, auth);
+    }
+}

package/contracts copy/kit/ERC20xTransferWithAuthorize.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "../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,
+        string memory domainName,
+        string memory domainVersion
+    )
+        ERC20(name, symbol)
+        TransferAuthorize(domainName, domainVersion)
+        Ownable(msg.sender)
+    {
+        _mint(msg.sender, initialSupply * 10 ** decimals());
+    }
+
+    /// @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 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyTransfer(
+            from,
+            to,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        require(signer == from, "transferWithAuthorize: 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 burnWithAuthorize(
+        address from,
+        uint256 value,
+        uint256 createTime,
+        uint256 expireTime,
+        bytes32 nonce,
+        bytes calldata auth
+    ) external override nonReentrant {
+        address signer = _verifyBurn(
+            from,
+            value,
+            createTime,
+            expireTime,
+            nonce,
+            auth
+        );
+        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.9",
+  "version": "0.0.10",
   "module": "index.ts",
   "type": "module",
   "devDependencies": {