add connector zevm test

contracts/zevm/ConnectorZEVM.sol → contracts/zevm/ZetaConnectorZEVM.sol

@@ -76,8 +76,8 @@ contract ZetaConnectorZEVM is ZetaInterfaces {
     );
     event SetWZETA(address wzeta_);
 
-    constructor(address _wzeta) {
-        wzeta = _wzeta;
+    constructor(address wzeta_) {
+        wzeta = wzeta_;
     }
 
     /// @dev Receive function to receive ZETA from WETH9.withdraw().

contracts/zevm/testing/MockSystemContract.sol → contracts/zevm/testing/SystemContractMock.sol

@@ -14,7 +14,7 @@ interface SystemContractErrors {
     error CantBeZeroAddress();
 }
 
-contract MockSystemContract is SystemContractErrors {
+contract SystemContractMock is SystemContractErrors {
     mapping(uint256 => uint256) public gasPriceByChainId;
     mapping(uint256 => address) public gasCoinZRC20ByChainId;
     mapping(uint256 => address) public gasZetaPoolByChainId;

test/ConnectorZEVM.spec.ts

@@ -0,0 +1,135 @@
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
+import { WETH9, ZetaConnectorZEVM } from "@typechain-types";
+import { expect } from "chai";
+import exp from "constants";
+import { parseEther } from "ethers/lib/utils";
+import { ethers } from "hardhat";
+
+import { FUNGIBLE_MODULE_ADDRESS } from "./test.helpers";
+
+const hre = require("hardhat");
+
+describe("ConnectorZEVM tests", () => {
+  let zetaTokenContract: WETH9;
+  let zetaConnectorZEVM: ZetaConnectorZEVM;
+
+  let owner: SignerWithAddress;
+  let fungibleModuleSigner: SignerWithAddress;
+  let addrs: SignerWithAddress[];
+  let randomSigner: SignerWithAddress;
+
+  beforeEach(async () => {
+    [owner, randomSigner, ...addrs] = await ethers.getSigners();
+
+    // Impersonate the fungible module account
+    await hre.network.provider.request({
+      method: "hardhat_impersonateAccount",
+      params: [FUNGIBLE_MODULE_ADDRESS],
+    });
+
+    // Get a signer for the fungible module account
+    fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS);
+    hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]);
+
+    const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9");
+    zetaTokenContract = (await WZETAFactory.deploy()) as WETH9;
+
+    const ZetaConnectorZEVMFactory = await ethers.getContractFactory("ZetaConnectorZEVM");
+    zetaConnectorZEVM = (await ZetaConnectorZEVMFactory.connect(owner).deploy(
+      zetaTokenContract.address
+    )) as ZetaConnectorZEVM;
+  });
+
+  describe("ZetaConnectorZEVM", () => {
+    it("Should revert if the zetaTxSender has no enough zeta", async () => {
+      await zetaTokenContract.connect(randomSigner).approve(zetaConnectorZEVM.address, 100_000);
+
+      const tx = zetaConnectorZEVM.connect(randomSigner).send({
+        destinationAddress: randomSigner.address,
+        destinationChainId: 1,
+        destinationGasLimit: 2500000,
+        message: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaParams: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaValueAndGas: 1000,
+      });
+
+      // @dev: As we use the standard WETH contract, there's no error message for not enough balance
+      await expect(tx).to.be.reverted;
+    });
+
+    it("Should revert if the zetaTxSender didn't allow ZetaConnector to spend Zeta token", async () => {
+      await zetaTokenContract.deposit({ value: 100_000 });
+      await zetaTokenContract.transfer(randomSigner.address, 100_000);
+
+      const balance = await zetaTokenContract.balanceOf(randomSigner.address);
+      expect(balance.toString()).to.equal("100000");
+
+      const tx = zetaConnectorZEVM.send({
+        destinationAddress: randomSigner.address,
+        destinationChainId: 1,
+        destinationGasLimit: 2500000,
+        message: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaParams: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaValueAndGas: 1000,
+      });
+
+      // @dev: As we use the standard WETH contract, there's no error message for not enough balance
+      await expect(tx).to.be.reverted;
+
+      await zetaTokenContract.connect(randomSigner).transfer(owner.address, balance);
+    });
+
+    it("Should emit `ZetaSent` on success", async () => {
+      const tx = await zetaConnectorZEVM.send({
+        destinationAddress: randomSigner.address,
+        destinationChainId: 1,
+        destinationGasLimit: 2500000,
+        message: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaParams: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaValueAndGas: 0,
+      });
+
+      expect(tx)
+        .to.emit(zetaConnectorZEVM, "ZetaSent")
+        .withArgs(owner.address, owner.address, 1, randomSigner.address, 0, 2500000, "hello", "hello");
+    });
+
+    it("Should transfer value and gas to fungible address", async () => {
+      const zetaValueAndGas = 1000;
+      await zetaTokenContract.approve(zetaConnectorZEVM.address, zetaValueAndGas);
+      await zetaTokenContract.deposit({ value: zetaValueAndGas });
+
+      const balanceBefore = await ethers.provider.getBalance(fungibleModuleSigner.address);
+
+      await zetaConnectorZEVM.send({
+        destinationAddress: randomSigner.address,
+        destinationChainId: 1,
+        destinationGasLimit: 2500000,
+        message: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaParams: new ethers.utils.AbiCoder().encode(["string"], ["hello"]),
+        zetaValueAndGas,
+      });
+
+      const balanceAfter = await ethers.provider.getBalance(fungibleModuleSigner.address);
+      expect(balanceAfter.sub(balanceBefore)).to.equal(zetaValueAndGas);
+    });
+
+    it("Should update wzeta address if is call from fungible address", async () => {
+      const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9");
+      const newZetaTokenContract = (await WZETAFactory.deploy()) as WETH9;
+
+      const tx = zetaConnectorZEVM.connect(fungibleModuleSigner).setWzetaAddress(newZetaTokenContract.address);
+      await expect(tx).to.emit(zetaConnectorZEVM, "SetWZETA").withArgs(newZetaTokenContract.address);
+
+      expect(await zetaConnectorZEVM.wzeta()).to.equal(newZetaTokenContract.address);
+    });
+
+    it("Should revert if try to update wzeta address from other address", async () => {
+      const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9");
+      const newZetaTokenContract = (await WZETAFactory.deploy()) as WETH9;
+
+      const tx = zetaConnectorZEVM.setWzetaAddress(newZetaTokenContract.address);
+      await expect(tx).to.be.revertedWith("OnlyFungibleModule");
+    });
+  });
+});

test/ZRC20.spec.ts

@@ -4,6 +4,8 @@ import { SystemContract, ZRC20 } from "@typechain-types";
 import { expect } from "chai";
 import { parseEther } from "ethers/lib/utils";
 import { ethers } from "hardhat";
+
+import { FUNGIBLE_MODULE_ADDRESS } from "./test.helpers";
 const hre = require("hardhat");
 
 describe("ZRC20 tests", () => {
@@ -15,8 +17,6 @@ describe("ZRC20 tests", () => {
   beforeEach(async () => {
     [owner, ...addrs] = await ethers.getSigners();
 
-    const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB";
-
     // Impersonate the fungible module account
     await hre.network.provider.request({
       method: "hardhat_impersonateAccount",
@@ -27,7 +27,7 @@ describe("ZRC20 tests", () => {
     fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS);
     hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]);
 
-    const SystemContractFactory = await ethers.getContractFactory("MockSystemContract");
+    const SystemContractFactory = await ethers.getContractFactory("SystemContractMock");
     systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract;
 
     const ZRC20Factory = await ethers.getContractFactory("ZRC20");

test/test.helpers.ts

@@ -1,6 +1,8 @@
 import { ZetaTokenConsumer__factory } from "@typechain-types";
 import { BigNumber, ContractReceipt } from "ethers";
 
+export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB";
+
 export const parseZetaConsumerLog = (logs: ContractReceipt["logs"]) => {
   const iface = ZetaTokenConsumer__factory.createInterface();
 

typechain-types/contracts/zevm/index.ts

@@ -1,8 +1,6 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import type * as connectorZevmSol from "./ConnectorZEVM.sol";
-export type { connectorZevmSol };
 import type * as interfacesSol from "./Interfaces.sol";
 export type { interfacesSol };
 import type * as systemContractSol from "./SystemContract.sol";
@@ -11,6 +9,8 @@ import type * as wzetaSol from "./WZETA.sol";
 export type { wzetaSol };
 import type * as zrc20Sol from "./ZRC20.sol";
 export type { zrc20Sol };
+import type * as zetaConnectorZevmSol from "./ZetaConnectorZEVM.sol";
+export type { zetaConnectorZevmSol };
 import type * as interfaces from "./interfaces";
 export type { interfaces };
 import type * as testing from "./testing";

typechain-types/contracts/zevm/testing/MockSystemContract.sol/MockSystemContract.ts → typechain-types/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock.ts

@@ -27,7 +27,7 @@ import type {
   PromiseOrValue,
 } from "../../../../common";
 
-export interface MockSystemContractInterface extends utils.Interface {
+export interface SystemContractMockInterface extends utils.Interface {
   functions: {
     "gasCoinZRC20ByChainId(uint256)": FunctionFragment;
     "gasPriceByChainId(uint256)": FunctionFragment;
@@ -220,12 +220,12 @@ export type SystemContractDeployedEvent = TypedEvent<
 export type SystemContractDeployedEventFilter =
   TypedEventFilter<SystemContractDeployedEvent>;
 
-export interface MockSystemContract extends BaseContract {
+export interface SystemContractMock extends BaseContract {
   connect(signerOrProvider: Signer | Provider | string): this;
   attach(addressOrName: string): this;
   deployed(): Promise<this>;
 
-  interface: MockSystemContractInterface;
+  interface: SystemContractMockInterface;
 
   queryFilter<TEvent extends TypedEvent>(
     event: TypedEventFilter<TEvent>,

typechain-types/contracts/zevm/testing/MockSystemContract.sol/index.ts → typechain-types/contracts/zevm/testing/SystemContractMock.sol/index.ts

@@ -1,5 +1,5 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-export type { MockSystemContract } from "./MockSystemContract";
 export type { SystemContractErrors } from "./SystemContractErrors";
+export type { SystemContractMock } from "./SystemContractMock";

typechain-types/contracts/zevm/testing/index.ts

@@ -1,5 +1,5 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import type * as mockSystemContractSol from "./MockSystemContract.sol";
-export type { mockSystemContractSol };
+import type * as systemContractMockSol from "./SystemContractMock.sol";
+export type { systemContractMockSol };

typechain-types/factories/contracts/zevm/ConnectorZEVM.sol/WZETA__factory.ts → typechain-types/factories/contracts/zevm/ZetaConnectorZEVM.sol/WZETA__factory.ts

@@ -7,7 +7,7 @@ import type { Provider } from "@ethersproject/providers";
 import type {
   WZETA,
   WZETAInterface,
-} from "../../../../contracts/zevm/ConnectorZEVM.sol/WZETA";
+} from "../../../../contracts/zevm/ZetaConnectorZEVM.sol/WZETA";
 
 const _abi = [
   {