1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

4
import "openzeppelin-contracts-08/access/Ownable.sol";
5
import "openzeppelin-contracts-08/token/ERC20/ERC20.sol";
6

7
interface DelegateERC20 {
8
    function delegateTransfer(address to, uint256 value, address origSender) external returns (bool);
9
}
10

11
interface IDetectionBot {
12
    function handleTransaction(address user, bytes calldata msgData) external;
13
}
14

15
interface IForta {
16
    function setDetectionBot(address detectionBotAddress) external;
17
    function notify(address user, bytes calldata msgData) external;
18
    function raiseAlert(address user) external;
19
}
20

21
contract Forta is IForta {
22
    mapping(address => IDetectionBot) public usersDetectionBots;
23
    mapping(address => uint256) public botRaisedAlerts;
24

25
    function setDetectionBot(address detectionBotAddress) external override {
26
        usersDetectionBots[msg.sender] = IDetectionBot(detectionBotAddress);
27
    }
28

29
    function notify(address user, bytes calldata msgData) external override {
30
        if (address(usersDetectionBots[user]) == address(0)) return;
31
        try usersDetectionBots[user].handleTransaction(user, msgData) {
32
            return;
33
        } catch {}
34
    }
35

36
    function raiseAlert(address user) external override {
37
        if (address(usersDetectionBots[user]) != msg.sender) return;
38
        botRaisedAlerts[msg.sender] += 1;
39
    }
40
}
41

42
contract CryptoVault {
43
    address public sweptTokensRecipient;
44
    IERC20 public underlying;
45

46
    constructor(address recipient) {
47
        sweptTokensRecipient = recipient;
48
    }
49

50
    function setUnderlying(address latestToken) public {
51
        require(address(underlying) == address(0), "Already set");
52
        underlying = IERC20(latestToken);
53
    }
54

55
    /*
56
    ...
57
    */
58

59
    function sweepToken(IERC20 token) public {
60
        require(token != underlying, "Can't transfer underlying token");
61
        token.transfer(sweptTokensRecipient, token.balanceOf(address(this)));
62
    }
63
}
64

65
contract LegacyToken is ERC20("LegacyToken", "LGT"), Ownable {
66
    DelegateERC20 public delegate;
67

68
    function mint(address to, uint256 amount) public onlyOwner {
69
        _mint(to, amount);
70
    }
71

72
    function delegateToNewContract(DelegateERC20 newContract) public onlyOwner {
73
        delegate = newContract;
74
    }
75

76
    function transfer(address to, uint256 value) public override returns (bool) {
77
        if (address(delegate) == address(0)) {
78
            return super.transfer(to, value);
79
        } else {
80
            return delegate.delegateTransfer(to, value, msg.sender);
81
        }
82
    }
83
}
84

85
contract DoubleEntryPoint is ERC20("DoubleEntryPointToken", "DET"), DelegateERC20, Ownable {
86
    address public cryptoVault;
87
    address public player;
88
    address public delegatedFrom;
89
    Forta public forta;
90

91
    constructor(address legacyToken, address vaultAddress, address fortaAddress, address playerAddress) {
92
        delegatedFrom = legacyToken;
93
        forta = Forta(fortaAddress);
94
        player = playerAddress;
95
        cryptoVault = vaultAddress;
96
        _mint(cryptoVault, 100 ether);
97
    }
98

99
    modifier onlyDelegateFrom() {
100
        require(msg.sender == delegatedFrom, "Not legacy contract");
101
        _;
102
    }
103

104
    modifier fortaNotify() {
105
        address detectionBot = address(forta.usersDetectionBots(player));
106

107
        // Cache old number of bot alerts
108
        uint256 previousValue = forta.botRaisedAlerts(detectionBot);
109

110
        // Notify Forta
111
        forta.notify(player, msg.data);
112

113
        // Continue execution
114
        _;
115

116
        // Check if alarms have been raised
117
        if (forta.botRaisedAlerts(detectionBot) > previousValue) revert("Alert has been triggered, reverting");
118
    }
119

120
    function delegateTransfer(address to, uint256 value, address origSender)
121
        public
122
        override
123
        onlyDelegateFrom
124
        fortaNotify
125
        returns (bool)
126
    {
127
        _transfer(origSender, to, value);
128
        return true;
129
    }
130
}

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.0;
3

4
interface IForta {
5
    function raiseAlert(address user) external;
6
}
7

8
contract DetectionBot {
9
    address public cryptoVault;
10

11
    constructor(address _cryptovault) {
12
        cryptoVault = _cryptovault;
13
    }
14

15
    function handleTransaction(address user, bytes calldata msgData) external {
16
        (,, address origSender) = abi.decode(msgData[4:], (address, uint256, address));
17

18
        if (origSender == cryptoVault) {
19
            IForta(msg.sender).raiseAlert(user);
20
        }
21
    }
22
}