Scoping

.gitignore

@@ -1,5 +1,8 @@
+.env
 .idea/
 /build
+/artifacts
+/cache
 .history/
 node_modules/
 gethdata/

README.md

@@ -1,5 +1,15 @@
 # chainbridge-solidity
 
+## SX Network Info
+
+This repo is based off `v1.0.0` of upstream repo https://github.com/ChainSafe/chainbridge-solidity.git.
+
+It is referenced by https://gitlab.com/nextgenbt/sx-network/chainbridge-deploy which maintains our version of the cb-sol-cli tool.
+
+Updates to ChainBridge-related contracts should be merged into the `master` branch here prior to cloning/pulling from the repo above.
+
+## ChainBridge
+
 [![Coverage Status](https://coveralls.io/repos/github/ChainSafe/chainbridge-solidity/badge.svg?branch=master)](https://coveralls.io/github/ChainSafe/chainbridge-solidity?branch=master)
 
 ChainBridge uses Solidity smart contracts to enable transfers to and from EVM compatible chains. These contracts consist of a core bridge contract (Bridge.sol) and a set of handler contracts (ERC20Handler.sol, ERC721Handler.sol, and GenericHandler.sol). The bridge contract is responsible for initiating, voting on, and executing proposed transfers. The handlers are used by the bridge contract to interact with other existing contracts.
@@ -29,5 +39,3 @@ Requires `nodejs` and `npm`.
 `make test`: Runs truffle tests.
 
 `make compile`: Compile contracts.
-
-

contracts/handlers/ERC20Handler.sol

@@ -1,31 +1,35 @@
 pragma solidity 0.6.4;
 pragma experimental ABIEncoderV2;
 
-import "../interfaces/IDepositExecute.sol";
-import "./HandlerHelpers.sol";
-import "../ERC20Safe.sol";
-import "@openzeppelin/contracts/presets/ERC20PresetMinterPauser.sol";
+import '../interfaces/IDepositExecute.sol';
+import './HandlerHelpers.sol';
+import '../ERC20Safe.sol';
+import '@openzeppelin/contracts/presets/ERC20PresetMinterPauser.sol';
 
 /**
     @title Handles ERC20 deposits and deposit executions.
     @author ChainSafe Systems.
     @notice This contract is intended to be used with the Bridge contract.
  */
 contract ERC20Handler is IDepositExecute, HandlerHelpers, ERC20Safe {
-    struct DepositRecord {
-        address _tokenAddress;
-        uint8    _lenDestinationRecipientAddress;
-        uint8   _destinationChainID;
-        bytes32 _resourceID;
-        bytes   _destinationRecipientAddress;
-        address _depositer;
-        uint    _amount;
-    }
+  struct DepositRecord {
+    address _tokenAddress;
+    uint8 _lenDestinationRecipientAddress;
+    uint8 _destinationChainID;
+    bytes32 _resourceID;
+    bytes _destinationRecipientAddress;
+    address _depositer;
+    uint256 _amount;
+  }
+
+  // depositNonce => Deposit Record
+  mapping(uint8 => mapping(uint64 => DepositRecord)) public _depositRecords;
+
+  event ERC20InitiateBridge(address indexed recipientAddress, bytes32 indexed resourceID, uint256 amount);
 
-    // depositNonce => Deposit Record
-    mapping (uint8 => mapping(uint64 => DepositRecord)) public _depositRecords;
+  event ERC20ProposalExecuted(address indexed recipientAddress, bytes32 indexed resourceID, uint256 amount);
 
-    /**
+  /**
         @param bridgeAddress Contract address of previously deployed Bridge.
         @param initialResourceIDs Resource IDs are used to identify a specific contract address.
         These are the Resource IDs this contract will initially support.
@@ -37,27 +41,26 @@ contract ERC20Handler is IDepositExecute, HandlerHelpers, ERC20Safe {
         @dev {initialResourceIDs} and {initialContractAddresses} must have the same length (one resourceID for every address).
         Also, these arrays must be ordered in the way that {initialResourceIDs}[0] is the intended resourceID for {initialContractAddresses}[0].
      */
-    constructor(
-        address          bridgeAddress,
-        bytes32[] memory initialResourceIDs,
-        address[] memory initialContractAddresses,
-        address[] memory burnableContractAddresses
-    ) public {
-        require(initialResourceIDs.length == initialContractAddresses.length,
-            "initialResourceIDs and initialContractAddresses len mismatch");
-
-        _bridgeAddress = bridgeAddress;
-
-        for (uint256 i = 0; i < initialResourceIDs.length; i++) {
-            _setResource(initialResourceIDs[i], initialContractAddresses[i]);
-        }
-
-        for (uint256 i = 0; i < burnableContractAddresses.length; i++) {
-            _setBurnable(burnableContractAddresses[i]);
-        }
+  constructor(
+    address bridgeAddress,
+    bytes32[] memory initialResourceIDs,
+    address[] memory initialContractAddresses,
+    address[] memory burnableContractAddresses
+  ) public {
+    require(initialResourceIDs.length == initialContractAddresses.length, 'initialResourceIDs and initialContractAddresses len mismatch');
+
+    _bridgeAddress = bridgeAddress;
+
+    for (uint256 i = 0; i < initialResourceIDs.length; i++) {
+      _setResource(initialResourceIDs[i], initialContractAddresses[i]);
+    }
+
+    for (uint256 i = 0; i < burnableContractAddresses.length; i++) {
+      _setBurnable(burnableContractAddresses[i]);
     }
+  }
 
-    /**
+  /**
         @param depositNonce This ID will have been generated by the Bridge contract.
         @param destId ID of chain deposit will be bridged to.
         @return DepositRecord which consists of:
@@ -69,11 +72,11 @@ contract ERC20Handler is IDepositExecute, HandlerHelpers, ERC20Safe {
         - _depositer Address that initially called {deposit} in the Bridge contract.
         - _amount Amount of tokens that were deposited.
     */
-    function getDepositRecord(uint64 depositNonce, uint8 destId) external view returns (DepositRecord memory) {
-        return _depositRecords[destId][depositNonce];
-    }
+  function getDepositRecord(uint64 depositNonce, uint8 destId) external view returns (DepositRecord memory) {
+    return _depositRecords[destId][depositNonce];
+  }
 
-    /**
+  /**
         @notice A deposit is initiatied by making a deposit in the Bridge contract.
         @param destinationChainID Chain ID of chain tokens are expected to be bridged to.
         @param depositNonce This value is generated as an ID by the Bridge contract.
@@ -86,54 +89,61 @@ contract ERC20Handler is IDepositExecute, HandlerHelpers, ERC20Safe {
         recipientAddress            bytes       bytes  64 - END
         @dev Depending if the corresponding {tokenAddress} for the parsed {resourceID} is
         marked true in {_burnList}, deposited tokens will be burned, if not, they will be locked.
+        @notice Emits {ERC20InitiateBridge} event with recipientAddress, resourceId, and amount.
      */
-    function deposit(
-        bytes32 resourceID,
-        uint8   destinationChainID,
-        uint64  depositNonce,
-        address depositer,
-        bytes   calldata data
-    ) external override onlyBridge {
-        bytes   memory recipientAddress;
-        uint256        amount;
-        uint256        lenRecipientAddress;
-
-        assembly {
-
-            amount := calldataload(0xC4)
-
-            recipientAddress := mload(0x40)
-            lenRecipientAddress := calldataload(0xE4)
-            mstore(0x40, add(0x20, add(recipientAddress, lenRecipientAddress)))
-
-            calldatacopy(
-                recipientAddress, // copy to destinationRecipientAddress
-                0xE4, // copy from calldata @ 0x104
-                sub(calldatasize(), 0xE) // copy size (calldatasize - 0x104)
-            )
-        }
-
-        address tokenAddress = _resourceIDToTokenContractAddress[resourceID];
-        require(_contractWhitelist[tokenAddress], "provided tokenAddress is not whitelisted");
-
-        if (_burnList[tokenAddress]) {
-            burnERC20(tokenAddress, depositer, amount);
-        } else {
-            lockERC20(tokenAddress, depositer, address(this), amount);
-        }
-
-        _depositRecords[destinationChainID][depositNonce] = DepositRecord(
-            tokenAddress,
-            uint8(lenRecipientAddress),
-            destinationChainID,
-            resourceID,
-            recipientAddress,
-            depositer,
-            amount
-        );
+  function deposit(
+    bytes32 resourceID,
+    uint8 destinationChainID,
+    uint64 depositNonce,
+    address depositer,
+    bytes calldata data
+  ) external override onlyBridge {
+    bytes memory recipientAddress;
+    uint256 amount;
+    uint256 lenRecipientAddress;
+
+    assembly {
+      amount := calldataload(0xC4)
+
+      recipientAddress := mload(0x40)
+      lenRecipientAddress := calldataload(0xE4)
+      mstore(0x40, add(0x20, add(recipientAddress, lenRecipientAddress)))
+
+      calldatacopy(
+        recipientAddress, // copy to destinationRecipientAddress
+        0xE4, // copy from calldata @ 0x104
+        sub(calldatasize(), 0xE) // copy size (calldatasize - 0x104)
+      )
     }
 
-    /**
+    address tokenAddress = _resourceIDToTokenContractAddress[resourceID];
+    require(_contractWhitelist[tokenAddress], 'provided tokenAddress is not whitelisted');
+
+    if (_burnList[tokenAddress]) {
+      // effectively 'burn' ERC20 that does not implement ERC20Burnable 'burnFrom()'
+      lockERC20(tokenAddress, depositer, address(0x000000000000000000000000000000000000dEaD), amount);
+    } else {
+      lockERC20(tokenAddress, depositer, address(this), amount);
+    }
+
+    _depositRecords[destinationChainID][depositNonce] = DepositRecord(
+      tokenAddress,
+      uint8(lenRecipientAddress),
+      destinationChainID,
+      resourceID,
+      recipientAddress,
+      depositer,
+      amount
+    );
+
+    bytes20 destinationRecipientAddress;
+    assembly {
+      destinationRecipientAddress := mload(add(recipientAddress, 0x20))
+    }
+    emit ERC20InitiateBridge(address(destinationRecipientAddress), resourceID, amount);
+  }
+
+  /**
         @notice Proposal execution should be initiated when a proposal is finalized in the Bridge contract.
         by a relayer on the deposit's destination chain.
         @param data Consists of {resourceID}, {amount}, {lenDestinationRecipientAddress},
@@ -142,49 +152,56 @@ contract ERC20Handler is IDepositExecute, HandlerHelpers, ERC20Safe {
         amount                                 uint256     bytes  0 - 32
         destinationRecipientAddress length     uint256     bytes  32 - 64
         destinationRecipientAddress            bytes       bytes  64 - END
+        @notice Emits {ERC20ProposalExecuted} event with recipientAddress, resourceId, and amount.
      */
-    function executeProposal(bytes32 resourceID, bytes calldata data) external override onlyBridge {
-        uint256       amount;
-        bytes  memory destinationRecipientAddress;
-
-        assembly {
-            amount := calldataload(0x64)
-
-            destinationRecipientAddress := mload(0x40)
-            let lenDestinationRecipientAddress := calldataload(0x84)
-            mstore(0x40, add(0x20, add(destinationRecipientAddress, lenDestinationRecipientAddress)))
-
-            // in the calldata the destinationRecipientAddress is stored at 0xC4 after accounting for the function signature and length declaration
-            calldatacopy(
-                destinationRecipientAddress, // copy to destinationRecipientAddress
-                0x84, // copy from calldata @ 0x84
-                sub(calldatasize(), 0x84) // copy size to the end of calldata
-            )
-        }
-
-        bytes20 recipientAddress;
-        address tokenAddress = _resourceIDToTokenContractAddress[resourceID];
-
-        assembly {
-            recipientAddress := mload(add(destinationRecipientAddress, 0x20))
-        }
-
-        require(_contractWhitelist[tokenAddress], "provided tokenAddress is not whitelisted");
-
-        if (_burnList[tokenAddress]) {
-            mintERC20(tokenAddress, address(recipientAddress), amount);
-        } else {
-            releaseERC20(tokenAddress, address(recipientAddress), amount);
-        }
+  function executeProposal(bytes32 resourceID, bytes calldata data) external override onlyBridge {
+    uint256 amount;
+    bytes memory destinationRecipientAddress;
+
+    assembly {
+      amount := calldataload(0x64)
+
+      destinationRecipientAddress := mload(0x40)
+      let lenDestinationRecipientAddress := calldataload(0x84)
+      mstore(0x40, add(0x20, add(destinationRecipientAddress, lenDestinationRecipientAddress)))
+
+      // in the calldata the destinationRecipientAddress is stored at 0xC4 after accounting for the function signature and length declaration
+      calldatacopy(
+        destinationRecipientAddress, // copy to destinationRecipientAddress
+        0x84, // copy from calldata @ 0x84
+        sub(calldatasize(), 0x84) // copy size to the end of calldata
+      )
     }
 
-    /**
+    bytes20 recipientAddress;
+    address tokenAddress = _resourceIDToTokenContractAddress[resourceID];
+
+    assembly {
+      recipientAddress := mload(add(destinationRecipientAddress, 0x20))
+    }
+
+    require(_contractWhitelist[tokenAddress], 'provided tokenAddress is not whitelisted');
+
+    if (_burnList[tokenAddress]) {
+      mintERC20(tokenAddress, address(recipientAddress), amount);
+    } else {
+      releaseERC20(tokenAddress, address(recipientAddress), amount);
+    }
+
+    emit ERC20ProposalExecuted(address(recipientAddress), resourceID, amount);
+  }
+
+  /**
         @notice Used to manually release ERC20 tokens from ERC20Safe.
         @param tokenAddress Address of token contract to release.
         @param recipient Address to release tokens to.
         @param amount The amount of ERC20 tokens to release.
      */
-    function withdraw(address tokenAddress, address recipient, uint amount) external override onlyBridge {
-        releaseERC20(tokenAddress, recipient, amount);
-    }
+  function withdraw(
+    address tokenAddress,
+    address recipient,
+    uint256 amount
+  ) external override onlyBridge {
+    releaseERC20(tokenAddress, recipient, amount);
+  }
 }