Synapse

1contract SynapseBridge is Initializable, AccessControlUpgradeable, ReentrancyGuardUpgradeable, PausableUpgradeable {
2    using SafeERC20 for IERC20;
3    using SafeERC20 for IERC20Mintable;
4    using SafeMath for uint256;
5
6    bytes32 public constant NODEGROUP_ROLE = keccak256("NODEGROUP_ROLE");
7    bytes32 public constant GOVERNANCE_ROLE = keccak256("GOVERNANCE_ROLE");
8
9    mapping(address => uint256) private fees;
10
11    uint256 public startBlockNumber;
12    uint256 public constant bridgeVersion = 6;
13    uint256 public chainGasAmount;
14    address payable public WETH_ADDRESS;
15
16    mapping(bytes32 => bool) private kappaMap;
17
18    receive() external payable {}
19
20    function initialize() external initializer {
21        startBlockNumber = block.number;
22        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
23        __AccessControl_init();
24    }
25
26    function setChainGasAmount(uint256 amount) external {
27        require(hasRole(GOVERNANCE_ROLE, msg.sender), "Not governance");
28        chainGasAmount = amount;
29    }
30
31    function setWethAddress(address payable _wethAddress) external {
32        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "Not admin");
33        WETH_ADDRESS = _wethAddress;
34    }
35
36    function addKappas(bytes32[] calldata kappas) external {
37        require(hasRole(GOVERNANCE_ROLE, msg.sender), "Not governance");
38        for (uint256 i = 0; i < kappas.length; ++i) {
39            kappaMap[kappas[i]] = true;
40        }
41    }
42
43    event TokenDeposit(address indexed to, uint256 chainId, IERC20 token, uint256 amount);
44    event TokenRedeem(address indexed to, uint256 chainId, IERC20 token, uint256 amount);
45    event TokenWithdraw(address indexed to, IERC20 token, uint256 amount, uint256 fee, bytes32 indexed kappa);
46    event TokenMint(address indexed to, IERC20Mintable token, uint256 amount, uint256 fee, bytes32 indexed kappa);
47    event TokenDepositAndSwap(
48        address indexed to,
49        uint256 chainId,
50        IERC20 token,
51        uint256 amount,
52        uint8 tokenIndexFrom,
53        uint8 tokenIndexTo,
54        uint256 minDy,
55        uint256 deadline
56    );
57    event TokenMintAndSwap(
58        address indexed to,
59        IERC20Mintable token,
60        uint256 amount,
61        uint256 fee,
62        uint8 tokenIndexFrom,
63        uint8 tokenIndexTo,
64        uint256 minDy,
65        uint256 deadline,
66        bool swapSuccess,
67        bytes32 indexed kappa
68    );
69    event TokenRedeemAndSwap(
70        address indexed to,
71        uint256 chainId,
72        IERC20 token,
73        uint256 amount,
74        uint8 tokenIndexFrom,
75        uint8 tokenIndexTo,
76        uint256 minDy,
77        uint256 deadline
78    );
79    event TokenRedeemAndRemove(
80        address indexed to,
81        uint256 chainId,
82        IERC20 token,
83        uint256 amount,
84        uint8 swapTokenIndex,
85        uint256 swapMinAmount,
86        uint256 swapDeadline
87    );
88    event TokenWithdrawAndRemove(
89        address indexed to,
90        IERC20 token,
91        uint256 amount,
92        uint256 fee,
93        uint8 swapTokenIndex,
94        uint256 swapMinAmount,
95        uint256 swapDeadline,
96        bool swapSuccess,
97        bytes32 indexed kappa
98    );
99
100    // v2 events
101    event TokenRedeemV2(bytes32 indexed to, uint256 chainId, IERC20 token, uint256 amount);
102
103    // VIEW FUNCTIONS ***/
104    function getFeeBalance(address tokenAddress) external view returns (uint256) {
105        return fees[tokenAddress];
106    }
107
108    function kappaExists(bytes32 kappa) external view returns (bool) {
109        return kappaMap[kappa];
110    }
111
112    // FEE FUNCTIONS ***/
113    /**
114     * * @notice withdraw specified ERC20 token fees to a given address
115     * * @param token ERC20 token in which fees acccumulated to transfer
116     * * @param to Address to send the fees to
117     */
118    function withdrawFees(IERC20 token, address to) external whenNotPaused {
119        require(hasRole(GOVERNANCE_ROLE, msg.sender), "Not governance");
120        require(to != address(0), "Address is 0x000");
121        if (fees[address(token)] != 0) {
122            token.safeTransfer(to, fees[address(token)]);
123            fees[address(token)] = 0;
124        }
125    }
126
127    // PAUSABLE FUNCTIONS ***/
128    function pause() external {
129        require(hasRole(GOVERNANCE_ROLE, msg.sender), "Not governance");
130        _pause();
131    }
132
133    function unpause() external {
134        require(hasRole(GOVERNANCE_ROLE, msg.sender), "Not governance");
135        _unpause();
136    }
137
138    /**
139     * @notice Relays to nodes to transfers an ERC20 token cross-chain
140     * @param to address on other chain to bridge assets to
141     * @param chainId which chain to bridge assets onto
142     * @param token ERC20 compatible token to deposit into the bridge
143     * @param amount Amount in native token decimals to transfer cross-chain pre-fees
144     **/
145    function deposit(
146        address to,
147        uint256 chainId,
148        IERC20 token,
149        uint256 amount
150    ) external nonReentrant whenNotPaused {
151        emit TokenDeposit(to, chainId, token, amount);
152        token.safeTransferFrom(msg.sender, address(this), amount);
153    }
154

JavaScript Tests