feat: add HodlChallege

Author: massun-onibakuchi

.env.example

@@ -0,0 +1,2 @@
+ALCHEMY_API_KEY=
+BLOCK_NUMBER=

README.md

@@ -39,6 +39,7 @@ yarn compile
 4. NftSaleChallenge.sol
 5. BankChallenge.sol
 6. WrappedERC20Challenge.sol
+7. HodleChallenge.sol (required to fork mainnet state)
 
 To run a test type:
 
@@ -47,6 +48,20 @@ To run a test type:
 yarn test test/<*Challenge>.test.ts
 ```
 
+Some of challenges are required to be run on forked network. You need access to an archive node like the free ones from [Alchemy](https://alchemyapi.io/). Create `.env` file and paste the api key.
+
+Type:
+
+```bash
+cp .env.example .env
+```
+
+Then set the environment variable.
+
+```bash
+ALCHEMY_API_KEY=<Your Alchemy api key>
+```
+
 ### About this challenges
 
 [Slide [ja]](https://docs.google.com/presentation/d/17FKtVC1S29WFnQjq92_SiqGIS6EGuslHsUfuNv-NlXU/edit?usp=sharing)

contracts/miscs/HodlChallenge.sol

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.10;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "./ProxyERC20.sol";
+
+/// @notice Challenge Description
+/// HodlVault allows an account to hold a token for a specific period.
+/// You can complete this challenge by empaty the following HodlVault for SNX.
+/// @notice This challenge is required to setup forking mainnet state.
+/// To run this challenge, You need access to an archive node like the free ones from Alchemy :https://alchemyapi.io/.
+
+contract HodlVault is ERC20 {
+    IERC20 public immutable token;
+
+    address public governance;
+
+    uint256 public unlocktimestamp;
+
+    uint256 public minDelayTime = 5 * 3600 * 24 * 365; // default 5 years
+
+    constructor(IERC20 _token, address _governance) ERC20("Hodl", "HODL") {
+        token = _token;
+        governance = _governance;
+    }
+
+    /// @notice deposit tokens and lock up for a certain period.
+    function hold(uint256 amount) external {
+        require(amount > 0, "zero");
+        unlocktimestamp = block.timestamp + minDelayTime;
+
+        token.transferFrom(msg.sender, address(this), amount);
+        _mint(msg.sender, amount);
+    }
+
+    /// @notice withdraw locked tokens if tokens can be unlocked
+    function withdraw(uint256 amount) external {
+        require(amount > 0, "zero");
+        require(block.timestamp > unlocktimestamp, "lock");
+
+        _burn(msg.sender, amount);
+        token.transfer(msg.sender, amount);
+    }
+
+    /// @notice rescue tokens accidentally send
+    function sweep(IERC20 _token) external {
+        // You can not rescue locked token.
+        require(token != _token, "!token");
+        _token.transfer(governance, _token.balanceOf(address(this)));
+    }
+
+    function updateGovernance(address _governance) external {
+        require(governance == msg.sender, "!gov");
+        require(_governance != address(0), "zero");
+
+        governance = _governance;
+    }
+
+    function updateMinDelayTime(uint256 _minDelayTime) external {
+        require(governance == msg.sender, "!gov");
+
+        minDelayTime = _minDelayTime;
+    }
+
+    function holdMethodIsCalled() external view returns (bool) {
+        return unlocktimestamp > 0;
+    }
+}
+
+contract HodlChallenge {
+    uint256 public constant SNAPSHOT_BLOCK_NUMBER = 14850000;
+
+    HodlVault public vault;
+
+    /// @notice SNX is an DeFi governance token.
+    /// This address is Mainnet Synthetix token. it implements ProxyERC20 interface
+    /// The source code can be found in the the following link :
+    /// https://etherscan.io/address/0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f#code
+    /// @dev
+    /// Hardhat mainnet forking is available.
+    /// await network.provider.request({
+    ///     method: 'hardhat_reset',
+    ///     params: [
+    ///       {
+    ///         forking: {
+    ///           jsonRpcUrl: <jsonRpcUrl> || hre.config.networks.hardhat.forking.url,
+    ///           blockNumber: <blockNumber>,
+    ///         },
+    ///       },
+    ///     ],
+    ///   })
+    /// To get some SNX hardhat_impersonateAccount is useful.
+    /// impersonate a SNX whale address such as 0xF977814e90dA44bFA03b6295A0616a897441aceC (Binance 8)
+    ///   await network.provider.request({
+    ///     method: 'hardhat_impersonateAccount',
+    ///     params: [address],
+    ///   })
+    ///   const signer = await ethers.getSigner(address)
+    IERC20 public constant SNX =
+        ProxyERC20(0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F);
+
+    constructor() {
+        // deploy HodlVault for SNX
+        vault = new HodlVault(SNX, address(this));
+    }
+
+    function isSolved() public view returns (bool) {
+        require(vault.holdMethodIsCalled(), "rule: lock SNX at least once");
+        return SNX.balanceOf(address(vault)) == 0;
+    }
+}

contracts/miscs/ProxyERC20.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.10;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+/// @title Synthetix-like proxy interface
+/// ref: SNX https://etherscan.io/address/0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f#code
+
+interface Proxyable is IERC20Metadata {
+    function proxy() external view returns (Proxy);
+
+    function setProxy(address payable _proxy) external;
+
+    function setMessageSender(address sender) external;
+}
+
+/**
+ * @notice
+ * A proxy contract that, if it does not recognise the function
+ * being called on it, passes all value and call data to an
+ * underlying target contract.
+ *
+ * This proxy has the capacity to toggle between DELEGATECALL
+ * and CALL style proxy functionality.
+ *
+ * The former executes in the proxy's context, and so will preserve
+ * msg.sender and store data at the proxy address. The latter will not.
+ * Therefore, any contract the proxy wraps in the CALL style must
+ * implement the Proxyable interface, in order that it can pass msg.sender
+ * into the underlying contract as the state parameter, messageSender.
+ **/
+interface Proxy {
+    function target() external view returns (Proxyable);
+
+    function useDELEGATECALL() external view returns (bool);
+
+    function setTarget(Proxyable _target) external;
+
+    function setUseDELEGATECALL(bool value) external;
+}
+
+/**
+ * @notice Synthetix-like proxy Implementaion with explicit ERC20 standard
+ **/
+interface ProxyERC20 is Proxy, IERC20Metadata {} // prettier-ignore

contracts/tokens/NftSaleChallenge.sol

@@ -4,7 +4,8 @@ pragma solidity 0.8.10;
 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
 
 /// @notice Challenge Description
-/// You can mint awesome nfts. but the nft contract limits the number of nft you can buy at a time. Mint at least 100 nfts within one transaction.
+/// You can mint awesome nfts. The nft contract seems to limits the number of nft accounts can buy at a time.
+/// Mint at least 100 nfts within one transaction.
 interface INft {
     function mint(uint256 numberOfNfts) external payable;
 

test/HodlChallenge.test.ts

@@ -0,0 +1,53 @@
+import { ethers } from 'hardhat'
+import { expect } from 'chai'
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers'
+import { ProxyERC20, HodlVault } from '../typechain-types'
+import { getImpersonatedSigner, resetFork } from './helpers/utils'
+
+/// @note provider url is required to run this challenge
+const PROVIDER_URL = `https://eth-mainnet.alchemyapi.io/v2/${process.env.ALCHEMY_API_KEY}`
+
+const BLOCK_NUMBER = 14850000
+const SNX = '0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F'
+const SNX_WHALE = '0xF977814e90dA44bFA03b6295A0616a897441aceC' // binance8
+
+describe('HodlChallenge', async function () {
+  let player: SignerWithAddress
+  let snx: ProxyERC20
+  let challenge
+  before(async function () {
+    await resetFork(BLOCK_NUMBER, PROVIDER_URL) // fork state at BLOCK_NUMBER
+    player = (await getImpersonatedSigner(SNX_WHALE)) as any
+
+    await ethers.provider.send('hardhat_setBalance', [
+      player.address,
+      '0xffffffffffffffffffffff',
+    ])
+
+    snx = (await ethers.getContractAt('ProxyERC20', SNX)) as ProxyERC20
+    challenge = await (
+      await ethers.getContractFactory('HodlChallenge')
+    ).deploy()
+
+    expect(await snx.name()).to.be.not.equal('') // check
+  })
+  after(async function () {
+    await resetFork(BLOCK_NUMBER, PROVIDER_URL)
+  })
+  it('Attack', async function () {
+    const vault = (await ethers.getContractFactory('HodlVault')).attach(
+      await challenge.vault()
+    ) as HodlVault
+
+    // deposit SNX at least once
+    const amotToDeposit = await snx.balanceOf(SNX_WHALE)
+    await snx.connect(player).approve(vault.address, amotToDeposit)
+    await vault.connect(player).hold(amotToDeposit)
+    expect(await vault.holdMethodIsCalled()).to.be.true // should be true
+
+    // TODO: Your solution below
+
+    // check
+    expect(await challenge.isSolved()).to.be.true
+  })
+})