Merge pull request #60 from AztecProtocol/pw/gas-logs

Emit gas consumption in logs for Element bridge

Author: PhilWindle

package.json

@@ -27,7 +27,7 @@
     "rootDir": "./src"
   },
   "name": "@aztec/bridge-clients",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "This repo contains the solidity files and typescript helper class for all of the Aztec Connect Bridge Contracts",
   "repository": "[email protected]:AztecProtocol/aztec-connect-bridges.git",
   "license": "MIT",

src/bridges/element/ElementBridge.sol

@@ -156,10 +156,10 @@ contract ElementBridge is IDefiBridge {
     uint256 internal constant MIN_GAS_FOR_EXPIRY_REMOVAL = 25000;
 
     // event emitted on every successful convert call
-    event LogConvert(uint256 indexed nonce, uint256 totalInputValue);
+    event LogConvert(uint256 indexed nonce, uint256 totalInputValue, int64 gasUsed);
 
     // event emitted on every attempt to finalise, successful or otherwise
-    event LogFinalise(uint256 indexed nonce, bool success, string message);
+    event LogFinalise(uint256 indexed nonce, bool success, string message, int64 gasUsed);
 
     // event emitted on wvery newly configured pool
     event LogPoolAdded(address poolAddress, address wrappedPositionAddress, uint64 expiry);
@@ -400,6 +400,13 @@ contract ElementBridge is IDefiBridge {
         hashValue = uint256(keccak256(abi.encodePacked(asset, uint256(expiry))));
     }
 
+    struct ConvertArgs {
+        address inputAssetAddress;
+        uint256 totalInputValue;
+        uint256 interactionNonce;
+        uint64 auxData;
+    }
+
     /**
      * @dev Function to add a new interaction to the bridge
      * Converts the amount of input asset given to the market determined amount of tranche asset
@@ -431,6 +438,8 @@ contract ElementBridge is IDefiBridge {
             bool isAsync
         )
     {
+        int64 gasAtStart = int64(int256(gasleft()));
+        int64 gasUsed = 0;
         // ### INITIALIZATION AND SANITY CHECKS
         if (msg.sender != rollupProcessor) {
             revert INVALID_CALLER();
@@ -449,36 +458,47 @@ contract ElementBridge is IDefiBridge {
         isAsync = true;
         outputValueA = 0;
         outputValueB = 0;
+
+        // capture the provided arguments in a struct to prevent 'stack too deep' errors
+        ConvertArgs memory convertArgs = ConvertArgs({
+            inputAssetAddress: inputAssetA.erc20Address,
+            totalInputValue: totalInputValue,
+            interactionNonce: interactionNonce,
+            auxData: auxData
+        });
+
         // retrieve the appropriate pool for this interaction and verify that it exists
-        Pool storage pool = pools[hashAssetAndExpiry(inputAssetA.erc20Address, auxData)];
+        Pool storage pool = pools[hashAssetAndExpiry(convertArgs.inputAssetAddress, convertArgs.auxData)];
         if (pool.trancheAddress == address(0)) {
             revert POOL_NOT_FOUND();
         }
         ITranche tranche = ITranche(pool.trancheAddress);
-        if (block.timestamp >= tranche.unlockTimestamp()) {
+        uint64 trancheExpiry = uint64(tranche.unlockTimestamp());
+        if (block.timestamp >= trancheExpiry) {
             revert TRANCHE_ALREADY_EXPIRED();
         }
-        uint64 trancheExpiry = uint64(tranche.unlockTimestamp());
+        
         // approve the transfer of tokens to the balancer address
-        ERC20(inputAssetA.erc20Address).approve(balancerAddress, totalInputValue);
+        ERC20(convertArgs.inputAssetAddress).approve(balancerAddress, convertArgs.totalInputValue);
         // execute the swap on balancer
-        uint256 principalTokensAmount = exchangeAssetForTrancheTokens(inputAssetA.erc20Address, pool, totalInputValue);
+        uint256 principalTokensAmount = exchangeAssetForTrancheTokens(convertArgs.inputAssetAddress, pool, convertArgs.totalInputValue);
         // store the tranche that underpins our interaction, the expiry and the number of received tokens against the nonce
-        Interaction storage newInteraction = interactions[interactionNonce];
+        Interaction storage newInteraction = interactions[convertArgs.interactionNonce];
         newInteraction.expiry = trancheExpiry;
         newInteraction.failed = false;
         newInteraction.finalised = false;
         newInteraction.quantityPT = principalTokensAmount;
         newInteraction.trancheAddress = pool.trancheAddress;
         // add the nonce and expiry to our expiry heap
-        addNonceAndExpiryToNonceMapping(interactionNonce, trancheExpiry);
+        addNonceAndExpiryToNonceMapping(convertArgs.interactionNonce, trancheExpiry);
         // increase our tranche account deposits and holdings
         // other members are left as their initial values (all zeros)
         TrancheAccount storage trancheAccount = trancheAccounts[newInteraction.trancheAddress];
         trancheAccount.numDeposits++;
         trancheAccount.quantityTokensHeld += newInteraction.quantityPT;
-        emit LogConvert(interactionNonce, totalInputValue);
-        finaliseExpiredInteractions(MIN_GAS_FOR_FUNCTION_COMPLETION);       
+        unchecked { gasUsed = gasAtStart - int64(int256(gasleft())); }
+        emit LogConvert(convertArgs.interactionNonce, convertArgs.totalInputValue, gasUsed);
+        finaliseExpiredInteractions(MIN_GAS_FOR_FUNCTION_COMPLETION);
         // we need to get here with MIN_GAS_FOR_FUNCTION_COMPLETION gas to exit.
     }
 
@@ -584,6 +604,8 @@ contract ElementBridge is IDefiBridge {
             bool interactionCompleted
         )
     {
+        int64 gasAtStart = int64(int256(gasleft()));
+        int64 gasUsed = 0;
         if (msg.sender != rollupProcessor) {
             revert INVALID_CALLER();
         }
@@ -602,7 +624,7 @@ contract ElementBridge is IDefiBridge {
         TrancheAccount storage trancheAccount = trancheAccounts[interaction.trancheAddress];
         if (trancheAccount.numDeposits == 0) {
             // shouldn't be possible, this means we have had no deposits against this tranche
-            setInteractionAsFailure(interaction, interactionNonce, 'NO_DEPOSITS_FOR_TRANCHE');
+            setInteractionAsFailure(interaction, interactionNonce, 'NO_DEPOSITS_FOR_TRANCHE', 0);
             popInteractionFromNonceMapping(interaction, interactionNonce);
             return (0, 0, false);
         }
@@ -617,12 +639,14 @@ contract ElementBridge is IDefiBridge {
                 trancheAccount.quantityAssetRemaining = valueRedeemed;
                 trancheAccount.redemptionStatus = TrancheRedemptionStatus.REDEMPTION_SUCCEEDED;
             } catch Error(string memory errorMessage) {
-                setInteractionAsFailure(interaction, interactionNonce, errorMessage);
+                unchecked { gasUsed = gasAtStart - int64(int256(gasleft())); }
+                setInteractionAsFailure(interaction, interactionNonce, errorMessage, gasUsed);
                 trancheAccount.redemptionStatus = TrancheRedemptionStatus.REDEMPTION_FAILED;
                 popInteractionFromNonceMapping(interaction, interactionNonce);
                 return (0, 0, false);
             } catch {
-                setInteractionAsFailure(interaction, interactionNonce, 'UNKNOWN_ERROR_FROM_TRANCHE_WITHDRAW');
+                unchecked { gasUsed = gasAtStart - int64(int256(gasleft())); }
+                setInteractionAsFailure(interaction, interactionNonce, 'UNKNOWN_ERROR_FROM_TRANCHE_WITHDRAW', gasUsed);
                 trancheAccount.redemptionStatus = TrancheRedemptionStatus.REDEMPTION_FAILED;
                 popInteractionFromNonceMapping(interaction, interactionNonce);
                 return (0, 0, false);
@@ -661,7 +685,8 @@ contract ElementBridge is IDefiBridge {
         outputValueA = amountToAllocate;
         outputValueB = 0;
         interactionCompleted = true;
-        emit LogFinalise(interactionNonce, interactionCompleted, '');
+        unchecked { gasUsed = gasAtStart - int64(int256(gasleft())); }
+        emit LogFinalise(interactionNonce, interactionCompleted, '', gasUsed);
     }
 
     /**
@@ -673,10 +698,11 @@ contract ElementBridge is IDefiBridge {
     function setInteractionAsFailure(
         Interaction storage interaction,
         uint256 interactionNonce,
-        string memory message
+        string memory message,
+        int64 gasUsed
     ) internal {
         interaction.failed = true;
-        emit LogFinalise(interactionNonce, false, message);
+        emit LogFinalise(interactionNonce, false, message, gasUsed);
     }
 
     /**
@@ -780,7 +806,7 @@ contract ElementBridge is IDefiBridge {
             (bool canBeFinalised, string memory message) = interactionCanBeFinalised(interaction);
             if (!canBeFinalised) {
                 // can't be finalised, add to failures and pop from nonces
-                setInteractionAsFailure(interaction, nextNonce, message);
+                setInteractionAsFailure(interaction, nextNonce, message, 0);
                 nonces.pop();
                 continue;
             }

src/test/element/Element.t.sol

@@ -99,9 +99,11 @@ contract ElementTest is DSTest {
     AztecTypes.AztecAsset emptyAsset;
     uint256 private numTranches = 0;
 
-    event LogConvert(uint256 indexed nonce, uint256 totalInputValue);
+    int64 constant daiConvertGas = 238860;
 
-    event LogFinalise(uint256 indexed nonce, bool success, string message);
+    event LogConvert(uint256 indexed nonce, uint256 totalInputValue, int64 gasUsed);
+
+    event LogFinalise(uint256 indexed nonce, bool success, string message, int64 gasUsed);
 
     event LogPoolAdded(address poolAddress, address wrappedPositionAddress, uint64 expiry);
 
@@ -688,7 +690,7 @@ contract ElementTest is DSTest {
         _setTokenBalance('DAI', address(elementBridge), interactionConfig.depositAmount);
         uint256 balancerBefore = tokens['DAI'].balanceOf(address(balancer));
         vm.expectEmit(false, false, false, true);
-        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount);
+        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount, daiConvertGas);
         (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callElementConvert('DAI', interactionConfig);
         assertEq(isAsync, true);
         assertEq(outputValueA, 0);
@@ -717,7 +719,7 @@ contract ElementTest is DSTest {
         _setTokenBalance('DAI', address(elementBridge), interactionConfig.depositAmount);
         uint256 balancerBefore = tokens['DAI'].balanceOf(address(balancer));
         vm.expectEmit(false, false, false, true);
-        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount);
+        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount, daiConvertGas);
         (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callElementConvert('DAI', interactionConfig);
         assertEq(isAsync, true);
         assertEq(outputValueA, 0);
@@ -751,7 +753,7 @@ contract ElementTest is DSTest {
         _setTokenBalance('DAI', address(elementBridge), interactionConfig.depositAmount * 2);
         uint256 balancerBefore = tokens['DAI'].balanceOf(address(balancer));
         vm.expectEmit(false, false, false, true);
-        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount);
+        emit LogConvert(interactionConfig.nonce, interactionConfig.depositAmount, daiConvertGas);
         (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callElementConvert('DAI', interactionConfig);
         assertEq(isAsync, true);
         assertEq(outputValueA, 0);
@@ -1139,7 +1141,7 @@ contract ElementTest is DSTest {
         // we expect 5 Finalise events to be emitted but we can't test the data values
         for (uint256 i = 0; i <  numUsdcInteractions; i++) {
             vm.expectEmit(false, false, false, false);
-            emit LogFinalise(1 + i, true, '');
+            emit LogFinalise(1 + i, true, '', 0);
         }
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
@@ -1203,7 +1205,7 @@ contract ElementTest is DSTest {
         // we expect 5 Finalise events to be emitted but we can't test the data values
         for (uint256 i = 0; i <  numEurInteractions; i++) {
             vm.expectEmit(false, false, false, false);
-            emit LogFinalise(1 + i, true, '');
+            emit LogFinalise(1 + i, true, '', 0);
         }
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
@@ -1358,7 +1360,7 @@ contract ElementTest is DSTest {
         // we expect 5 Finalise events to be emitted but we can't test the data values
         for (uint256 i = 0; i <  numEurInteractions; i++) {
             vm.expectEmit(false, false, false, false);
-            emit LogFinalise(1 + i, true, '');
+            emit LogFinalise(1 + i, true, '', 0);
         }
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
@@ -1439,7 +1441,7 @@ contract ElementTest is DSTest {
         _increaseTokenBalance(asset, address(rollupProcessor), daiDepositAmount);
         // we expect 1 Finalise events to be emitted but we can't test the data values
         vm.expectEmit(false, false, false, true);
-        emit LogFinalise(5, true, '');
+        emit LogFinalise(5, true, '', 225337);
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
             assertEq(isAsync, true);
@@ -1503,8 +1505,8 @@ contract ElementTest is DSTest {
         // we expect 2 Finalise events to be emitted but we can't test the data values
         uint numExpectedFinalisedInteractions = 2;
         vm.expectEmit(false, false, false, false);
-        emit LogFinalise(5, true, '');
-        emit LogFinalise(4, true, '');
+        emit LogFinalise(5, true, '', 0);
+        emit LogFinalise(4, true, '', 0);
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
             assertEq(isAsync, true);
@@ -1568,9 +1570,9 @@ contract ElementTest is DSTest {
         // we expect 3 Finalise events to be emitted but we can't test the data values
         uint numExpectedFinalisedInteractions = 3;
         vm.expectEmit(false, false, false, false);
-        emit LogFinalise(5, true, '');
-        emit LogFinalise(4, true, '');
-        emit LogFinalise(3, true, '');
+        emit LogFinalise(5, true, '', 0);
+        emit LogFinalise(4, true, '', 0);
+        emit LogFinalise(3, true, '', 0);
         {
             (uint256 outputValueA, uint256 outputValueB, bool isAsync) = _callRollupConvert(asset, daiInteraction);
             assertEq(isAsync, true);