diff --git a/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewards.sol b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewards.sol index f06efe6..9b022a2 100644 --- a/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewards.sol +++ b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewards.sol @@ -52,7 +52,7 @@ contract InstantRewards is Ownable2Step, Pausable, ReentrancyGuard, EIP712 { if (block.timestamp > claimData.sigExpiration) revert SignatureExpired(); } - function claim(ClaimData memory claimData) external nonReentrant whenNotPaused { + function claim(ClaimData memory claimData) public virtual nonReentrant whenNotPaused { claimData.to = msg.sender; _verify(claimData); @@ -72,7 +72,7 @@ contract InstantRewards is Ownable2Step, Pausable, ReentrancyGuard, EIP712 { emit SignerUpdated(signerAddress_); } - function withdraw(address wallet, uint256 amount) external onlyOwner { + function withdraw(address wallet, uint256 amount) public virtual onlyOwner { if (wallet == address(0)) revert InvalidAddress(); if (amount > address(this).balance) revert TransferFailed(); (bool success, ) = wallet.call{value: amount}(""); diff --git a/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsFactory.sol b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsFactory.sol new file mode 100644 index 0000000..1674b28 --- /dev/null +++ b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsFactory.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "@openzeppelin/contracts/access/Ownable2Step.sol"; +import "./InstantRewardsV2.sol"; + +contract InstantRewardsFactory is Ownable2Step { + event InstantRewardsCreated(address indexed instantRewards, address indexed owner); + + function createInstantRewards( + address signerAddress, + uint256 start, + uint256 end, + string memory name + ) external returns (address) { + InstantRewardsV2 instantRewards = new InstantRewardsV2(signerAddress, owner(), start, end, name); + instantRewards.transferOwnership(owner()); + emit InstantRewardsCreated(address(instantRewards), owner()); + return address(instantRewards); + } +} diff --git a/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsV2.sol b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsV2.sol new file mode 100644 index 0000000..8750088 --- /dev/null +++ b/packages/zevm-app-contracts/contracts/instant-rewards/InstantRewardsV2.sol @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "./InstantRewards.sol"; + +contract InstantRewardsV2 is InstantRewards { + string public name; + + uint256 public start; + uint256 public end; + + event TimeframeUpdated(uint256 start, uint256 end); + + error InvalidTimeframe(); + error InstantRewardNotActive(); + error InstantRewardStillActive(); + + constructor( + address signerAddress_, + address owner, + uint256 start_, + uint256 end_, + string memory name_ + ) InstantRewards(signerAddress_, owner) { + if (signerAddress_ == address(0)) revert InvalidAddress(); + if (start_ > end_) revert InvalidTimeframe(); + start = start_; + end = end_; + name = name_; + } + + function isActive() public view returns (bool) { + return block.timestamp >= start && block.timestamp <= end; + } + + function setTimeframe(uint256 start_, uint256 end_) external onlyOwner { + if (start_ > end_) revert InvalidTimeframe(); + if (start_ < block.timestamp || end_ < block.timestamp) revert InvalidTimeframe(); + if (isActive()) revert InstantRewardStillActive(); + start = start_; + end = end_; + emit TimeframeUpdated(start_, end_); + } + + function claim(ClaimData memory claimData) public override { + if (!isActive()) revert InstantRewardNotActive(); + super.claim(claimData); + } + + function withdraw(address wallet, uint256 amount) public override { + if (isActive()) revert InstantRewardStillActive(); + super.withdraw(wallet, amount); + } +} diff --git a/packages/zevm-app-contracts/test/instant-rewards/instant-rewards-v2-compatibility.ts b/packages/zevm-app-contracts/test/instant-rewards/instant-rewards-v2-compatibility.ts new file mode 100644 index 0000000..bfc21ff --- /dev/null +++ b/packages/zevm-app-contracts/test/instant-rewards/instant-rewards-v2-compatibility.ts @@ -0,0 +1,337 @@ +import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; +import { expect } from "chai"; +import { BigNumber, utils } from "ethers"; +import { parseEther } from "ethers/lib/utils"; +import { ethers } from "hardhat"; + +import { InstantRewardsV2 } from "../../typechain-types"; +import { ClaimData, getSignature } from "./test.helpers"; + +const HARDHAT_CHAIN_ID = 1337; + +describe("Instant Rewards Contract test", () => { + let instantRewards: InstantRewardsV2, + owner: SignerWithAddress, + signer: SignerWithAddress, + user: SignerWithAddress, + addrs: SignerWithAddress[]; + + const encodeTaskId = (taskId: string) => utils.keccak256(utils.defaultAbiCoder.encode(["string"], [taskId])); + + const getClaimDataSigned = async ( + chainId: number, + verifyingContract: string, + signer: SignerWithAddress, + amount: BigNumber, + sigExpiration: number, + taskId: string, + to: string + ) => { + const claimData: ClaimData = { + amount, + sigExpiration, + taskId, + to, + }; + + const signature = await getSignature(chainId, verifyingContract, signer, claimData); + return { + ...claimData, + signature, + }; + }; + + beforeEach(async () => { + [owner, signer, user, ...addrs] = await ethers.getSigners(); + const instantRewardsFactory = await ethers.getContractFactory("InstantRewardsV2"); + + const start = (await ethers.provider.getBlock("latest")).timestamp + 1; + const end = start + 1000; + + instantRewards = await instantRewardsFactory.deploy(signer.address, owner.address, start, end, "Instant Rewards"); + + await instantRewards.deployed(); + }); + + it("Should claim", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.emit(instantRewards, "Claimed").withArgs(owner.address, taskId, amount); + }); + + it("Should claim if pause and unpause", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + await instantRewards.pause(); + await instantRewards.unpause(); + + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.emit(instantRewards, "Claimed").withArgs(owner.address, taskId, amount); + }); + + it("Should revert if try to claim on behalf of somebody else", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = user.address; + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("InvalidSigner"); + }); + + it("Should revert if try to claim with an expired signature", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp - 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("SignatureExpired"); + }); + + it("Should revert if try to claim when contract it's paused", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + await instantRewards.pause(); + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("Pausable: paused"); + }); + + it("Should revert if try to claim twice with same signature", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + instantRewards.claim(claimDataSigned); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("TaskAlreadyClaimed"); + }); + + it("Should revert if try to claim same task with another signature", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("1"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + { + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + instantRewards.claim(claimDataSigned); + } + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount.add(parseEther("1")), + sigExpiration, + taskId, + to + ); + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("TaskAlreadyClaimed"); + }); + + it("Should revert if try to claim with an old valid signature if a new one was used", async () => { + const currentBlock = await ethers.provider.getBlock("latest"); + const sigExpiration = currentBlock.timestamp + 1000; + const amount = utils.parseEther("2"); + const taskId = encodeTaskId("WALLET/TASK/EPOC"); + const to = owner.address; + + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const claimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration, + taskId, + to + ); + + const newClaimDataSigned = await getClaimDataSigned( + HARDHAT_CHAIN_ID, + instantRewards.address, + signer, + amount, + sigExpiration + 1000, + taskId, + to + ); + + instantRewards.claim(newClaimDataSigned); + + const tx = instantRewards.claim(claimDataSigned); + await expect(tx).to.revertedWith("TaskAlreadyClaimed"); + }); + + it("Should revert if not owner try to pause", async () => { + const tx = instantRewards.connect(user).pause(); + await expect(tx).to.revertedWith("Ownable: caller is not the owner"); + }); + + it("Should transfer ownership", async () => { + { + const ownerAddr = await instantRewards.owner(); + expect(ownerAddr).to.be.eq(owner.address); + } + await instantRewards.transferOwnership(user.address); + await instantRewards.connect(user).acceptOwnership(); + { + const ownerAddr = await instantRewards.owner(); + expect(ownerAddr).to.be.eq(user.address); + } + }); + + it("Should withdraw by owner", async () => { + await ethers.provider.send("evm_increaseTime", [7200]); // Fast forward 2 hours to ensure voting delay is over + await ethers.provider.send("evm_mine", []); // Mine the next block + + const amount = utils.parseEther("2"); + const amountToWithdraw = utils.parseEther("1"); + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const userBalanceBefore = await ethers.provider.getBalance(user.address); + + const tx = instantRewards.withdraw(user.address, amountToWithdraw); + await expect(tx).to.emit(instantRewards, "Withdrawn").withArgs(user.address, amountToWithdraw); + + const balanceOfContract = await ethers.provider.getBalance(instantRewards.address); + expect(balanceOfContract).to.be.eq(amount.sub(amountToWithdraw)); + const balanceOfUser = await ethers.provider.getBalance(user.address); + expect(balanceOfUser).to.be.eq(userBalanceBefore.add(amountToWithdraw)); + }); + + it("Should fail if try to withdraw an active IR", async () => { + const amount = utils.parseEther("2"); + const amountToWithdraw = utils.parseEther("1"); + // transfer some funds to the contract + await owner.sendTransaction({ + to: instantRewards.address, + value: amount, + }); + + const tx = instantRewards.withdraw(user.address, amountToWithdraw); + await expect(tx).to.revertedWith("InstantRewardStillActive"); + }); +});