chore: run forge fmt

.gitignore

@@ -1,3 +1,4 @@
+venv
 .gitignore
 .env
 node_modules
@@ -26,4 +27,4 @@ gambit_out/
 test-mutation/mutant_test_env/
 
 # bridged usdc deployment script
-registerUsdcGatewayTx.json
+registerUsdcGatewayTx.json

contracts/rpc-utils/MulticallV2.sol

@@ -17,6 +17,7 @@ contract Multicall2 {
         address target;
         bytes callData;
     }
+
     struct Result {
         bool success;
         bytes returnData;
@@ -37,11 +38,7 @@ contract Multicall2 {
 
     function blockAndAggregate(Call[] memory calls)
         public
-        returns (
-            uint256 blockNumber,
-            bytes32 blockHash,
-            Result[] memory returnData
-        )
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
     {
         (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
     }
@@ -115,11 +112,7 @@ contract Multicall2 {
 
     function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
         public
-        returns (
-            uint256 blockNumber,
-            bytes32 blockHash,
-            Result[] memory returnData
-        )
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
     {
         blockNumber = block.number;
         blockHash = blockhash(block.number);
@@ -133,6 +126,7 @@ contract ArbMulticall2 {
         address target;
         bytes callData;
     }
+
     struct Result {
         bool success;
         bytes returnData;
@@ -153,11 +147,7 @@ contract ArbMulticall2 {
 
     function blockAndAggregate(Call[] memory calls)
         public
-        returns (
-            uint256 blockNumber,
-            bytes32 blockHash,
-            Result[] memory returnData
-        )
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
     {
         (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
     }
@@ -235,11 +225,7 @@ contract ArbMulticall2 {
 
     function tryBlockAndAggregate(bool requireSuccess, Call[] memory calls)
         public
-        returns (
-            uint256 blockNumber,
-            bytes32 blockHash,
-            Result[] memory returnData
-        )
+        returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)
     {
         blockNumber = ArbSys(address(100)).arbBlockNumber();
         blockHash = blockhash(block.number);

contracts/rpc-utils/NodeInterface.sol

@@ -2,11 +2,11 @@
 // solhint-disable-next-line compiler-version
 pragma solidity >=0.4.21 <0.9.0;
 
-/** @title Interface for providing Outbox proof data
+/**
+ * @title Interface for providing Outbox proof data
  *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at 0x00000000000000000000000000000000000000C8
  * This is a cute trick to allow an Arbitrum node to provide data without us having to implement an additional RPC )
  */
-
 interface NodeInterface {
     /**
      * @notice Returns the proof necessary to redeem a message

contracts/rpc-utils/RetryableTicketCreator.sol

@@ -4,16 +4,16 @@ pragma solidity >=0.4.21 <0.9.0;
 
 interface RetryableTicketCreator {
     /**
-    @notice Put an message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
-    * @dev all msg.value will deposited to callValueRefundAddress on L2
-    * @param destAddr destination L2 contract address
-    * @param l2CallValue call value for retryable L2 message 
-    * @param  maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
-    * @param excessFeeRefundAddress maxgas x gasprice - execution cost gets credited here on L2 balance
-    * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
-    * @param maxGas Max gas deducted from user's L2 balance to cover L2 execution
-    * @param gasPriceBid price bid for L2 execution
-    * @param data ABI encoded data of L2 message 
+     * @notice Put an message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
+     * @dev all msg.value will deposited to callValueRefundAddress on L2
+     * @param destAddr destination L2 contract address
+     * @param l2CallValue call value for retryable L2 message
+     * @param  maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
+     * @param excessFeeRefundAddress maxgas x gasprice - execution cost gets credited here on L2 balance
+     * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+     * @param maxGas Max gas deducted from user's L2 balance to cover L2 execution
+     * @param gasPriceBid price bid for L2 execution
+     * @param data ABI encoded data of L2 message
      */
     function createRetryableTicket(
         address destAddr,

contracts/tokenbridge/arbitrum/L2ArbitrumMessenger.sol

@@ -27,13 +27,11 @@ abstract contract L2ArbitrumMessenger {
 
     event TxToL1(address indexed _from, address indexed _to, uint256 indexed _id, bytes _data);
 
-    function sendTxToL1(
-        uint256 _l1CallValue,
-        address _from,
-        address _to,
-        bytes memory _data
-    ) internal returns (uint256) {
-        uint256 _id = ArbSys(ARB_SYS_ADDRESS).sendTxToL1{ value: _l1CallValue }(_to, _data);
+    function sendTxToL1(uint256 _l1CallValue, address _from, address _to, bytes memory _data)
+        internal
+        returns (uint256)
+    {
+        uint256 _id = ArbSys(ARB_SYS_ADDRESS).sendTxToL1{value: _l1CallValue}(_to, _data);
         emit TxToL1(_from, _to, _id, _data);
         return _id;
     }

contracts/tokenbridge/arbitrum/StandardArbERC20.sol

@@ -32,6 +32,7 @@ contract StandardArbERC20 is IArbToken, L2GatewayToken, Cloneable {
         bool ignoreName;
         bool ignoreSymbol;
     }
+
     ERC20Getters private availableGetters;
 
     /**
@@ -41,10 +42,8 @@ contract StandardArbERC20 is IArbToken, L2GatewayToken, Cloneable {
      * @param _data encoded symbol/name/decimal data for initial deploy
      */
     function bridgeInit(address _l1Address, bytes memory _data) public virtual {
-        (bytes memory name_, bytes memory symbol_, bytes memory decimals_) = abi.decode(
-            _data,
-            (bytes, bytes, bytes)
-        );
+        (bytes memory name_, bytes memory symbol_, bytes memory decimals_) =
+            abi.decode(_data, (bytes, bytes, bytes));
         // what if decode reverts? shouldn't as this is encoded by L1 contract
 
         /*

contracts/tokenbridge/arbitrum/gateway/L2ArbitrumGateway.sol

@@ -38,10 +38,7 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
     uint256 public exitNum;
 
     event DepositFinalized(
-        address indexed l1Token,
-        address indexed _from,
-        address indexed _to,
-        uint256 _amount
+        address indexed l1Token, address indexed _from, address indexed _to, uint256 _amount
     );
 
     event WithdrawalInitiated(
@@ -85,14 +82,13 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
 
         // exitNum incremented after being included in _outboundCalldata
         exitNum++;
-        return
-            sendTxToL1(
-                // default to sending no callvalue to the L1
-                0,
-                _from,
-                counterpartGateway,
-                _outboundCalldata
-            );
+        return sendTxToL1(
+            // default to sending no callvalue to the L1
+            0,
+            _from,
+            counterpartGateway,
+            _outboundCalldata
+        );
     }
 
     function getOutboundCalldata(
@@ -114,12 +110,11 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
         return outboundCalldata;
     }
 
-    function outboundTransfer(
-        address _l1Token,
-        address _to,
-        uint256 _amount,
-        bytes calldata _data
-    ) public payable returns (bytes memory) {
+    function outboundTransfer(address _l1Token, address _to, uint256 _amount, bytes calldata _data)
+        public
+        payable
+        returns (bytes memory)
+    {
         return outboundTransfer(_l1Token, _to, _amount, 0, 0, _data);
     }
 
@@ -182,19 +177,17 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
         uint256 currExitNum = exitNum;
         // unique id used to identify the L2 to L1 tx
         uint256 id = createOutboundTx(
-            _from,
-            _amount,
-            getOutboundCalldata(_l1Token, _from, _to, _amount, _data)
+            _from, _amount, getOutboundCalldata(_l1Token, _from, _to, _amount, _data)
         );
         emit WithdrawalInitiated(_l1Token, _from, _to, id, currExitNum, _amount);
         return id;
     }
 
-    function outboundEscrowTransfer(
-        address _l2Token,
-        address _from,
-        uint256 _amount
-    ) internal virtual returns (uint256 amountBurnt) {
+    function outboundEscrowTransfer(address _l2Token, address _from, uint256 _amount)
+        internal
+        virtual
+        returns (uint256 amountBurnt)
+    {
         // this method is virtual since different subclasses can handle escrow differently
         // user funds are escrowed on the gateway using this function
         // burns L2 tokens in order to release escrowed L1 tokens
@@ -204,11 +197,10 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
         return _amount;
     }
 
-    function inboundEscrowTransfer(
-        address _l2Address,
-        address _dest,
-        uint256 _amount
-    ) internal virtual {
+    function inboundEscrowTransfer(address _l2Address, address _dest, uint256 _amount)
+        internal
+        virtual
+    {
         // this method is virtual since different subclasses can handle escrow differently
         IArbToken(_l2Address).bridgeMint(_dest, _amount);
     }
@@ -231,8 +223,8 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
         uint256 _amount,
         bytes calldata _data
     ) external payable override onlyCounterpartGateway {
-        (bytes memory gatewayData, bytes memory callHookData) = GatewayMessageHandler
-            .parseFromL1GatewayMsg(_data);
+        (bytes memory gatewayData, bytes memory callHookData) =
+            GatewayMessageHandler.parseFromL1GatewayMsg(_data);
 
         if (callHookData.length != 0) {
             // callHookData should always be 0 since inboundEscrowAndCall is disabled
@@ -242,14 +234,8 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
         address expectedAddress = calculateL2TokenAddress(_token);
 
         if (!expectedAddress.isContract()) {
-            bool shouldHalt = handleNoContract(
-                _token,
-                expectedAddress,
-                _from,
-                _to,
-                _amount,
-                gatewayData
-            );
+            bool shouldHalt =
+                handleNoContract(_token, expectedAddress, _from, _to, _amount, gatewayData);
             if (shouldHalt) return;
         }
 
@@ -307,4 +293,4 @@ abstract contract L2ArbitrumGateway is L2ArbitrumMessenger, TokenGateway {
 
         return true;
     }
-}
+}

contracts/tokenbridge/arbitrum/gateway/L2ERC20Gateway.sol

@@ -27,11 +27,9 @@ import "../../libraries/ClonableBeaconProxy.sol";
 contract L2ERC20Gateway is L2ArbitrumGateway {
     address public beaconProxyFactory;
 
-    function initialize(
-        address _l1Counterpart,
-        address _router,
-        address _beaconProxyFactory
-    ) public {
+    function initialize(address _l1Counterpart, address _router, address _beaconProxyFactory)
+        public
+    {
         L2ArbitrumGateway._initialize(_l1Counterpart, _router);
         require(_beaconProxyFactory != address(0), "INVALID_BEACON");
         beaconProxyFactory = _beaconProxyFactory;
@@ -52,11 +50,9 @@ contract L2ERC20Gateway is L2ArbitrumGateway {
         returns (address)
     {
         // this method is marked virtual to be overriden in subclasses used in testing
-        return
-            BeaconProxyFactory(beaconProxyFactory).calculateExpectedAddress(
-                address(this),
-                getUserSalt(l1ERC20)
-            );
+        return BeaconProxyFactory(beaconProxyFactory).calculateExpectedAddress(
+            address(this), getUserSalt(l1ERC20)
+        );
     }
 
     function cloneableProxyHash() public view returns (bytes32) {

contracts/tokenbridge/arbitrum/gateway/L2GatewayRouter.sol

@@ -53,12 +53,11 @@ contract L2GatewayRouter is GatewayRouter, L2ArbitrumMessenger {
         }
     }
 
-    function outboundTransfer(
-        address _l1Token,
-        address _to,
-        uint256 _amount,
-        bytes calldata _data
-    ) public payable returns (bytes memory) {
+    function outboundTransfer(address _l1Token, address _to, uint256 _amount, bytes calldata _data)
+        public
+        payable
+        returns (bytes memory)
+    {
         return outboundTransfer(_l1Token, _to, _amount, 0, 0, _data);
     }
 

contracts/tokenbridge/arbitrum/gateway/L2ReverseCustomGateway.sol

@@ -36,19 +36,19 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 contract L2ReverseCustomGateway is L2CustomGateway {
     using SafeERC20 for IERC20;
 
-    function inboundEscrowTransfer(
-        address _l2Token,
-        address _dest,
-        uint256 _amount
-    ) internal virtual override {
+    function inboundEscrowTransfer(address _l2Token, address _dest, uint256 _amount)
+        internal
+        virtual
+        override
+    {
         IERC20(_l2Token).safeTransfer(_dest, _amount);
     }
 
-    function outboundEscrowTransfer(
-        address _l2Token,
-        address _from,
-        uint256 _amount
-    ) internal override returns (uint256) {
+    function outboundEscrowTransfer(address _l2Token, address _from, uint256 _amount)
+        internal
+        override
+        returns (uint256)
+    {
         uint256 prevBalance = IERC20(_l2Token).balanceOf(address(this));
         // as in the normal custom gateway, in the reverse custom gateway we check
         // for the balances of tokens to ensure that inflationary / deflationary changes in the amount