feat: ZetaChain.omniChainSwap() function

contracts/OnlySystem.sol

@@ -4,10 +4,16 @@ pragma solidity ^0.8.7;
 import "@zetachain/protocol-contracts/contracts/zevm/SystemContract.sol";
 
 contract OnlySystem {
+    address internal systemContractAddress;
+
     error OnlySystemContract(string);
 
-    modifier onlySystem(SystemContract systemContract) {
-        if (msg.sender != address(systemContract)) {
+    constructor(address _systemContractAddress) {
+        systemContractAddress = _systemContractAddress;
+    }
+
+    modifier onlySystem() {
+        if (msg.sender != systemContractAddress) {
             revert OnlySystemContract(
                 "Only system contract can call this function"
             );

contracts/ZetaChain.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.7;
+
+import "./OnlySystem.sol";
+import "./BytesHelperLib.sol";
+import "./SwapHelperLib.sol";
+import "@zetachain/protocol-contracts/contracts/zevm/SystemContract.sol";
+import "@zetachain/protocol-contracts/contracts/zevm/interfaces/IWZETA.sol";
+
+abstract contract ZetaChain is zContract, OnlySystem {
+    SystemContract public systemContract;
+    mapping(uint256 => address) private systemContracts;
+
+    constructor() OnlySystem(_initializeSystemContracts()) {
+        address systemContractAddress = systemContracts[block.chainid];
+        systemContract = SystemContract(systemContractAddress);
+    }
+
+    function _initializeSystemContracts() private returns (address) {
+        systemContracts[7000] = 0x91d18e54DAf4F677cB28167158d6dd21F6aB3921;
+        systemContracts[7001] = 0xEdf1c3275d13489aCdC6cD6eD246E72458B8795B;
+        return systemContracts[block.chainid];
+    }
+
+    function omniChainSwap(
+        zContext calldata context,
+        address zrc20,
+        uint256 amount,
+        bytes calldata message
+    ) internal virtual {
+        address target;
+        bytes memory to;
+
+        if (context.chainID == 18332) {
+            target = BytesHelperLib.bytesToAddress(message, 0);
+            to = abi.encodePacked(BytesHelperLib.bytesToAddress(message, 20));
+        } else {
+            (address targetToken, bytes memory recipient) = abi.decode(
+                message,
+                (address, bytes)
+            );
+            target = targetToken;
+            to = recipient;
+        }
+
+        address wzeta = systemContract.wZetaContractAddress();
+        bool isTargetZeta = target == wzeta;
+        uint256 inputForGas;
+        address gasZRC20;
+        uint256 gasFee;
+
+        if (!isTargetZeta) {
+            (gasZRC20, gasFee) = IZRC20(target).withdrawGasFee();
+
+            inputForGas = SwapHelperLib.swapTokensForExactTokens(
+                systemContract,
+                zrc20,
+                gasFee,
+                gasZRC20,
+                amount
+            );
+        }
+
+        uint256 outputAmount = SwapHelperLib.swapExactTokensForTokens(
+            systemContract,
+            zrc20,
+            isTargetZeta ? amount : amount - inputForGas,
+            target,
+            0
+        );
+
+        if (isTargetZeta) {
+            IWETH9(wzeta).transfer(address(uint160(bytes20(to))), outputAmount);
+        } else {
+            IZRC20(gasZRC20).approve(target, gasFee);
+            IZRC20(target).withdraw(to, outputAmount);
+        }
+    }
+}

package.json

@@ -107,5 +107,6 @@
     "spinnies": "^0.5.1",
     "tiny-secp256k1": "^2.2.3",
     "ws": "^8.13.0"
-  }
-}
+  },
+  "packageManager": "[email protected]+sha1.1959a18351b811cdeedbd484a8f86c3cc3bbaf72"
+}

packages/tasks/templates/omnichain/contracts/{{contractName}}.sol.hbs

@@ -1,23 +1,17 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.7;
 
-import "@zetachain/protocol-contracts/contracts/zevm/SystemContract.sol";
-import "@zetachain/protocol-contracts/contracts/zevm/interfaces/zContract.sol";
-import "@zetachain/toolkit/contracts/OnlySystem.sol";
+import "@zetachain/toolkit/contracts/ZetaChain.sol";
 
-contract {{contractName}} is zContract, OnlySystem {
-    SystemContract public systemContract;
-
-    constructor(address systemContractAddress) {
-        systemContract = SystemContract(systemContractAddress);
-    }
+contract {{contractName}} is ZetaChain {
+    constructor() ZetaChain() {}
 
     function onCrossChainCall(
         zContext calldata context,
         address zrc20,
         uint256 amount,
         bytes calldata message
-    ) external virtual override onlySystem(systemContract) {
+    ) external override onlySystem {
         {{#if arguments.pairsWithDataLocation}}
         ({{#each arguments.pairsWithDataLocation}}{{#if @index}}, {{/if}}{{this.[1]}} {{this.[0]}}{{/each}}) = abi.decode(
             message,

packages/tasks/templates/omnichain/tasks/deploy.ts.hbs

@@ -18,10 +18,8 @@ const main = async (args: any, hre: HardhatRuntimeEnvironment) => {
     );
   }
 
-  const systemContract = getAddress("systemContract", network);
-
   const factory = await hre.ethers.getContractFactory(args.name);
-  const contract = await factory.deploy(systemContract);
+  const contract = await factory.deploy();
   await contract.deployed();
 
   const isTestnet = network === "zeta_testnet";

typechain-types/@openzeppelin/contracts/index.ts

@@ -1,5 +1,7 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
+import type * as access from "./access";
+export type { access };
 import type * as token from "./token";
 export type { token };

typechain-types/@zetachain/protocol-contracts/contracts/evm/index.ts

@@ -3,3 +3,5 @@
 /* eslint-disable */
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as tools from "./tools";
+export type { tools };

typechain-types/@zetachain/protocol-contracts/contracts/evm/interfaces/index.ts

@@ -3,3 +3,4 @@
 /* eslint-disable */
 import type * as zetaInterfacesSol from "./ZetaInterfaces.sol";
 export type { zetaInterfacesSol };
+export type { ZetaInteractorErrors } from "./ZetaInteractorErrors";