Add tests based on Ampleforth Geyser v2 tests

contracts/mock/MockDelegate.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.7.6;
+
+import {IRageQuit, IUniversalVault} from "../crucible/Crucible.sol";
+
+contract MockDelegate is IRageQuit {
+    enum DelegateType {Succeed, Revert, RevertWithMessage, OOG}
+
+    DelegateType private _delegateType;
+
+    function setDelegateType(DelegateType delegateType) external {
+        _delegateType = delegateType;
+    }
+
+    function rageQuit() external view override {
+        if (_delegateType == DelegateType.Succeed) {
+            return;
+        } else if (_delegateType == DelegateType.Revert) {
+            revert();
+        } else if (_delegateType == DelegateType.RevertWithMessage) {
+            require(false, "MockDelegate: revert with message");
+        } else if (_delegateType == DelegateType.OOG) {
+            while (true) {}
+        }
+    }
+
+    function lock(
+        address vault,
+        address token,
+        uint256 amount,
+        bytes memory permission
+    ) external {
+        IUniversalVault(vault).lock(token, amount, permission);
+    }
+
+    function unlock(
+        address vault,
+        address token,
+        uint256 amount,
+        bytes memory permission
+    ) external {
+        IUniversalVault(vault).unlock(token, amount, permission);
+    }
+}

contracts/mock/MockERC1271.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.7.6;
+
+import {ERC1271} from "../crucible/ERC1271.sol";
+
+contract MockERC1271 is ERC1271 {
+    address public owner;
+
+    constructor(address _owner) {
+        owner = _owner;
+    }
+
+    function _getOwner() internal view override returns (address) {
+        return owner;
+    }
+}

contracts/mock/MockPowered.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.7.6;
+
+import {Powered} from "../aludel/Powered.sol";
+
+contract MockPowered is Powered {
+    constructor(address powerSwitch) {
+        Powered._setPowerSwitch(powerSwitch);
+    }
+
+    function onlyOnlineCall() public view onlyOnline {
+        return;
+    }
+
+    function onlyOfflineCall() public view onlyOffline {
+        return;
+    }
+
+    function notShutdownCall() public view notShutdown {
+        return;
+    }
+
+    function onlyShutdownCall() public view onlyShutdown {
+        return;
+    }
+}

contracts/mock/MockSmartWallet.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.7.6;
+
+import {ERC1271} from "../crucible/ERC1271.sol";
+
+contract MockSmartWallet is ERC1271 {
+    address private _owner;
+
+    constructor(address owner) {
+        _owner = owner;
+    }
+
+    function _getOwner() internal view override returns (address) {
+        return _owner;
+    }
+}

contracts/mock/MockStakeHelper.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity 0.7.6;
+pragma abicoder v2;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {Aludel} from "../aludel/Aludel.sol";
+
+contract MockStakeHelper {
+    function flashStake(
+        address geyser,
+        address vault,
+        uint256 amount,
+        bytes calldata lockPermission,
+        bytes calldata unstakePermission
+    ) external {
+        Aludel(geyser).stake(vault, amount, lockPermission);
+        Aludel(geyser).unstakeAndClaim(vault, amount, unstakePermission);
+    }
+
+    function stakeBatch(
+        address[] calldata geysers,
+        address[] calldata vaults,
+        uint256[] calldata amounts,
+        bytes[] calldata permissions
+    ) external {
+        for (uint256 index = 0; index < vaults.length; index++) {
+            Aludel(geysers[index]).stake(vaults[index], amounts[index], permissions[index]);
+        }
+    }
+}

test/Access/ERC1271.ts

@@ -0,0 +1,47 @@
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/dist/src/signer-with-address'
+import { expect } from 'chai'
+import { Contract } from 'ethers'
+import { hashMessage, keccak256 } from 'ethers/lib/utils'
+import { ethers } from 'hardhat'
+import { deployContract } from '../utils'
+
+describe('ERC1271', function () {
+  let accounts: SignerWithAddress[]
+  let MockERC1271: Contract
+  const message = hashMessage('ERC1271 test message')
+  let VALID_SIG: string
+  const INVALID_SIG = '0x00000000'
+
+  function toEthSignedMessageHash(messageHex: string) {
+    const messageBuffer = Buffer.from(messageHex.substring(2), 'hex')
+    const prefix = Buffer.from(`\u0019Ethereum Signed Message:\n${messageBuffer.length}`)
+    return keccak256(Buffer.concat([prefix, messageBuffer]))
+  }
+
+  beforeEach(async function () {
+    // prepare signers
+    accounts = await ethers.getSigners()
+    // deploy mock
+    MockERC1271 = await deployContract('MockERC1271', [accounts[0].address])
+    VALID_SIG = MockERC1271.interface.getSighash('isValidSignature(bytes32,bytes)')
+  })
+
+  describe('isValidSignature', function () {
+    it('should return error value if signed by account other than owner', async function () {
+      const sig = await accounts[1].signMessage(message)
+      expect(await MockERC1271.isValidSignature(toEthSignedMessageHash(message), sig)).to.eq(INVALID_SIG)
+    })
+
+    it('should revert if signature has incorrect length', async function () {
+      const sig = await accounts[0].signMessage(message)
+      expect(MockERC1271.isValidSignature(toEthSignedMessageHash(message), sig.slice(0, 10))).to.be.revertedWith(
+        'ECDSA: invalid signature length',
+      )
+    })
+
+    it('should return success value if signed by owner', async function () {
+      const sig = await accounts[0].signMessage(message)
+      expect(await MockERC1271.isValidSignature(hashMessage(message), sig)).to.eq(VALID_SIG)
+    })
+  })
+})