feat: initialize a prototypes

contracts/prototypes/ERC20CustodyNew.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.7;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./Gateway.sol";
+
+// As the current version, ERC20CustodyNew hold the ERC20s deposited on ZetaChain
+// This version include a functionality allowing to call a contract
+// ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract
+contract ERC20CustodyNew {
+    Gateway public gateway;
+
+    event Withdraw(address indexed token, address indexed to, uint256 amount);
+    event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data);
+
+    constructor(address _gateway) {
+        gateway = Gateway(_gateway);
+    }
+
+    // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call
+    function withdraw(address token, address to, uint256 amount) external {
+        IERC20(token).transfer(to, amount);
+
+        emit Withdraw(token, to, amount);
+    }
+
+    // WithdrawAndCall is called by TSS address, it transfers the tokens and call a contract
+    // For this, it passes through the Gateway contract, it transfers the tokens to the Gateway contract and then calls the contract
+    function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external {
+        // Transfer the tokens to the Gateway contract
+        IERC20(token).transfer(address(gateway), amount);
+
+        // Forward the call to the Gateway contract
+        gateway.executeWithERC20(token, to, amount, data);
+
+        emit WithdrawAndCall(token, to, amount, data);
+    }
+}

contracts/prototypes/Gateway.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.7;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./ERC20CustodyNew.sol";
+
+// The Gateway contract is the endpoint to call smart contracts on external chains
+// The contract doesn't hold any funds and should never have active allowances
+contract Gateway {
+    error ExecutionFailed();
+
+    ERC20CustodyNew public custody;
+
+    event Executed(address indexed destination, uint256 value, bytes data);
+    event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data);
+
+    function _execute(address destination, bytes calldata data) internal returns (bytes memory) {
+        (bool success, bytes memory result) = destination.call{value: msg.value}(data);
+
+        if (!success) {
+            revert ExecutionFailed();
+        }
+
+        return result;
+    }
+
+    // Called by the TSS
+    // Execution without ERC20 tokens, it is payable and can be used in the case of WithdrawAndCall for Gas ZRC20
+    // It can be also used for contract call without asset movement
+    function execute(address destination, bytes calldata data) external payable returns (bytes memory) {
+        bytes memory result = _execute(destination, data);
+
+        emit Executed(destination, msg.value, data);
+
+        return result;
+    }
+
+    // Called by the ERC20Custody contract
+    // It call a function using ERC20 transfer
+    // Since the goal is to allow calling contract not designed for ZetaChain specifically, it uses ERC20 allowance system
+    // It provides allowance to destination contract and call destination contract. In the end, it remove remaining allowance and transfer remaining tokens back to the custody contract for security purposes
+    function executeWithERC20(
+        address token,
+        address to,
+        uint256 amount,
+        bytes calldata data
+    ) external returns (bytes memory) {
+        // Approve the target contract to spend the tokens
+        IERC20(token).approve(to, amount);
+
+        // Execute the call on the target contract
+        bytes memory result = _execute(to, data);
+
+        // Reset approval
+        IERC20(token).approve(to, 0);
+
+        // Transfer any remaining tokens back to the custody contract
+        uint256 remainingBalance = IERC20(token).balanceOf(address(this));
+        if (remainingBalance > 0) {
+            IERC20(token).transfer(address(custody), remainingBalance);
+        }
+
+        emit ExecutedWithERC20(token, to, amount, data);
+
+        return result;
+    }
+
+    function setCustody(address _custody) external {
+        custody = ERC20CustodyNew(_custody);
+    }
+}

contracts/prototypes/Receiver.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.7;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract Receiver {
+    event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag);
+    event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag);
+    event ReceivedC(address sender, uint256 amount, address token, address destination);
+    event ReceivedD(address sender);
+
+    // Payable function
+    function receiveA(string memory str, uint256 num, bool flag) external payable {
+        emit ReceivedA(msg.sender, msg.value, str, num, flag);
+    }
+
+    // Non-payable function
+    function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external {
+        emit ReceivedB(msg.sender, strs, nums, flag);
+    }
+
+    // Function using IERC20
+    function receiveC(uint256 amount, address token, address destination) external {
+        // Transfer tokens from the Gateway contract to the destination address
+        IERC20(token).transferFrom(msg.sender, destination, amount);
+
+        emit ReceivedC(msg.sender, amount, token, destination);
+    }
+
+    // Function without parameters
+    function receiveD() external {
+        emit ReceivedD(msg.sender);
+    }
+}

contracts/prototypes/TestERC20.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.7;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract TestERC20 is ERC20 {
+    constructor(string memory name, string memory symbol) ERC20(name, symbol) {}
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}

docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/contract.ZetaTokenConsumerZEVM.md

@@ -0,0 +1,94 @@
+# ZetaTokenConsumerZEVM
+[Git Source](https://github.com/zeta-chain/protocol-contracts/blob/6aed43c93d3900874969a54408401c17997e7cb9/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol)
+
+**Inherits:**
+[ZetaTokenConsumer](/contracts/evm/interfaces/ZetaInterfaces.sol/interface.ZetaTokenConsumer.md), [ZetaTokenConsumerZEVMErrors](/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md)
+
+*ZetaTokenConsumer for ZEVM*
+
+
+## State Variables
+### MAX_DEADLINE
+
+```solidity
+uint256 internal constant MAX_DEADLINE = 200;
+```
+
+
+### WETH9Address
+
+```solidity
+address public immutable WETH9Address;
+```
+
+
+### uniswapV2Router
+
+```solidity
+IUniswapV2Router02 internal immutable uniswapV2Router;
+```
+
+
+## Functions
+### constructor
+
+
+```solidity
+constructor(address WETH9Address_, address uniswapV2Router_);
+```
+
+### getZetaFromEth
+
+
+```solidity
+function getZetaFromEth(address destinationAddress, uint256 minAmountOut) external payable override returns (uint256);
+```
+
+### getZetaFromToken
+
+
+```solidity
+function getZetaFromToken(
+    address destinationAddress,
+    uint256 minAmountOut,
+    address inputToken,
+    uint256 inputTokenAmount
+) external override returns (uint256);
+```
+
+### getEthFromZeta
+
+
+```solidity
+function getEthFromZeta(address destinationAddress, uint256 minAmountOut, uint256 zetaTokenAmount)
+    external
+    override
+    returns (uint256);
+```
+
+### getTokenFromZeta
+
+
+```solidity
+function getTokenFromZeta(
+    address destinationAddress,
+    uint256 minAmountOut,
+    address outputToken,
+    uint256 zetaTokenAmount
+) external override returns (uint256);
+```
+
+### hasZetaLiquidity
+
+
+```solidity
+function hasZetaLiquidity() external view override returns (bool);
+```
+
+### receive
+
+
+```solidity
+receive() external payable;
+```
+

docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md

@@ -0,0 +1,53 @@
+# ZetaTokenConsumerZEVMErrors
+[Git Source](https://github.com/zeta-chain/protocol-contracts/blob/6aed43c93d3900874969a54408401c17997e7cb9/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol)
+
+
+## Errors
+### InputCantBeZero
+
+```solidity
+error InputCantBeZero();
+```
+
+### ErrorSendingETH
+
+```solidity
+error ErrorSendingETH();
+```
+
+### ReentrancyError
+
+```solidity
+error ReentrancyError();
+```
+
+### NotEnoughValue
+
+```solidity
+error NotEnoughValue();
+```
+
+### InputCantBeZeta
+
+```solidity
+error InputCantBeZeta();
+```
+
+### OutputCantBeZeta
+
+```solidity
+error OutputCantBeZeta();
+```
+
+### OnlyWZETAAllowed
+
+```solidity
+error OnlyWZETAAllowed();
+```
+
+### InvalidForZEVM
+
+```solidity
+error InvalidForZEVM();
+```
+

hardhat.config.ts

@@ -3,6 +3,7 @@ import "@nomicfoundation/hardhat-verify";
 import "@typechain/hardhat";
 import "tsconfig-paths/register";
 import "hardhat-abi-exporter";
+import "uniswap-v2-deploy-plugin";
 import "./tasks/addresses";
 
 import { getHardhatConfigNetworks } from "@zetachain/networks";

package.json

@@ -53,7 +53,8 @@
     "ts-node": "10.8.1",
     "tsconfig-paths": "^3.14.1",
     "typechain": "^8.1.0",
-    "typescript": "^4.6.3"
+    "typescript": "^4.6.3",
+    "uniswap-v2-deploy-plugin": "^0.0.4"
   },
   "files": [
     "contracts",
@@ -78,6 +79,7 @@
     "lint:fix": "npx eslint . --ext .js,.ts,.json --fix",
     "prepublishOnly": "yarn build",
     "test": "yarn compile && npx hardhat test",
+    "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*",
     "tsc:watch": "npx tsc --watch"
   },
   "types": "./dist/lib/index.d.ts",