feat(GasEstimate): new base contract for gas estimation

contracts/gas/GasEstimate.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { IGasEstimate } from '../interfaces/IGasEstimate.sol';
+
+/**
+ * @title AxelarGasService
+ * @notice This contract manages gas payments and refunds for cross-chain communication on the Axelar network.
+ * @dev The owner address of this contract should be the microservice that pays for gas.
+ * @dev Users pay gas for cross-chain calls, and the gasCollector can collect accumulated fees and/or refund users if needed.
+ */
+contract GasEstimate is IGasEstimate {
+    // keccak256('GasEstimate.Slot') - 1
+    bytes32 internal constant GAS_SERVICE_SLOT = 0x2fa150da4c9f4c3a28593398c65313dd42f63d0530ec6db4a2b46e6d837a3902;
+
+    struct GasServiceStorage {
+        mapping(string => GasInfo) gasPrices;
+    }
+
+    /**
+     * @notice Sets the gas price for a specific chain.
+     * @dev This function is called by the gas oracle to update the gas price for a specific chain.
+     * @param chain The name of the chain
+     * @param gasInfo The gas info for the chain
+     */
+    function _setGasInfo(string calldata chain, GasInfo calldata gasInfo) internal {
+        emit GasInfoUpdated(chain, gasInfo);
+
+        _gasServiceStorage().gasPrices[chain] = gasInfo;
+    }
+
+    /**
+     * @notice Estimates the gas fee for a contract call on a destination chain.
+     * @param destinationChain Axelar registered name of the destination chain
+     * param destinationAddress Destination contract address being called
+     * @param executionGasLimit The gas limit to be used for the destination contract execution,
+     *        e.g. pass in 200k if your app consumes needs upto 200k for this contract call
+     * @return gasEstimate The cross-chain gas estimate, in terms of source chain's native gas token that should be forwarded to the gas service.
+     */
+    function estimateGasFee(
+        string calldata destinationChain,
+        string calldata, /* destinationAddress */
+        bytes calldata payload,
+        uint256 executionGasLimit
+    ) external view returns (uint256 gasEstimate) {
+        GasServiceStorage storage slot = _gasServiceStorage();
+        GasInfo storage gasInfo = slot.gasPrices[destinationChain];
+
+        gasEstimate = gasInfo.baseFee + (executionGasLimit * gasInfo.relativeGasPrice);
+
+        // if chain is L2, compute L1 data fee using L1 gas price info
+        if (gasInfo.extraFee != ExtraFeeType.None) {
+            gasEstimate += computeExtraFee(gasInfo.extraFee, payload, slot.gasPrices['ethereum'].relativeGasPrice);
+        }
+    }
+
+    /**
+     * @notice Computes the L1 to L2 fee for a contract call on a destination chain.
+     * @param feeType The type of extra fee
+     * @param payload The payload of the contract call
+     * @param l1GasPrice The gas price on the source chain
+     * @return l1DataFee The L1 to L2 data fee
+     */
+    function computeExtraFee(
+        ExtraFeeType feeType,
+        bytes calldata payload,
+        uint256 l1GasPrice
+    ) internal pure returns (uint256) {
+        if (feeType == ExtraFeeType.OptimismEcotone) {
+            return optimismEcotoneL1Fee(payload, l1GasPrice);
+        }
+
+        revert UnsupportedExtraFeeType(feeType);
+    }
+
+    /**
+     * @notice Computes the L1 to L2 fee for a contract call on the Optimism chain.
+     * @param payload The payload of the contract call
+     * @param l1GasPrice The base fee for L1 to L2
+     * @return l1DataFee The L1 to L2 data fee
+     */
+    function optimismEcotoneL1Fee(bytes calldata payload, uint256 l1GasPrice)
+        internal
+        pure
+        returns (uint256 l1DataFee)
+    {
+        /* Optimism Ecotone gas model https://docs.optimism.io/stack/transactions/fees#ecotone
+             tx_compressed_size = ((count_zero_bytes(tx_data) * 4 + count_non_zero_bytes(tx_data) * 16)) / 16
+             weighted_gas_price = 16 * base_fee_scalar*base_fee + blob_base_fee_scalar * blob_base_fee
+             l1_data_fee = tx_compressed_size * weighted_gas_price
+
+           Reference implementation:
+             https://github.com/ethereum-optimism/optimism/blob/876e16ad04968f0bb641eb76f98eb77e7e1a3e16/packages/contracts-bedrock/src/L2/GasPriceOracle.sol#L138
+        */
+
+        // The new base_fee_scalar is currently set to 0.001368
+        // We are setting it to un upper bound of 0.0015 to account for possible fluctuations
+        uint256 scalarPrecision = 10**6;
+        uint256 baseFeeScalar = 1500; // 1500 : 1e6 = 0.0015
+
+        // The blob_base_fee_scalar is currently set to 0.810949. Setting it to 0.9 as an upper bound
+        // https://eips.ethereum.org/EIPS/eip-4844
+        uint256 blobBaseFeeScalar = 900000; // 0.9 multiplied by scalarPrecision
+        uint256 blobBaseFee = 1;
+
+        // Calculating transaction size in bytes that will later be divided by 16 to compress the size
+        // 68 bytes for the TX RLP encoding overhead
+        uint256 txSize = 68 * 16;
+        // GMP executeWithToken call parameters
+        // 4 bytes for method selector, 32 bytes for the commandId, 96 bytes for the sourceChain, 128 bytes for the sourceAddress, 96 bytes for token symbol, 32 bytes for amount
+        // Expecting most of the calldata bytes to be zeroes. So multiplying by 8 as a weighted average of 4 and 16
+        txSize += (4 + 32 + 96 + 128 + 96 + 32) * 8;
+
+        for (uint256 i; i < payload.length; ++i) {
+            if (payload[i] == 0) {
+                txSize += 4; // 4 for each zero byte
+            } else {
+                txSize += 16; // 16 for each non-zero byte
+            }
+        }
+
+        uint256 weightedGasPrice = 16 * baseFeeScalar * l1GasPrice + blobBaseFeeScalar * blobBaseFee;
+
+        l1DataFee = (weightedGasPrice * txSize) / (16 * scalarPrecision); // 16 for txSize compression and scalar precision conversion
+    }
+
+    /**
+     * @notice Get the storage slot for the GasServiceStorage struct
+     */
+    function _gasServiceStorage() private pure returns (GasServiceStorage storage slot) {
+        assembly {
+            slot.slot := GAS_SERVICE_SLOT
+        }
+    }
+}

contracts/interfaces/IAxelarGasService.sol

@@ -2,19 +2,20 @@
 
 pragma solidity ^0.8.0;
 
-import { IUpgradable } from '../interfaces/IUpgradable.sol';
+import { IGasEstimate } from './IGasEstimate.sol';
+import { IUpgradable } from './IUpgradable.sol';
 
 /**
  * @title IAxelarGasService Interface
  * @notice This is an interface for the AxelarGasService contract which manages gas payments
  * and refunds for cross-chain communication on the Axelar network.
  * @dev This interface inherits IUpgradable
  */
-interface IAxelarGasService is IUpgradable {
-    error NothingReceived();
+interface IAxelarGasService is IGasEstimate, IUpgradable {
     error InvalidAddress();
     error NotCollector();
     error InvalidAmounts();
+    error InvalidGasUpdates();
 
     event GasPaidForContractCall(
         address indexed sourceAddress,
@@ -265,7 +266,7 @@ interface IAxelarGasService is IUpgradable {
 
     /**
      * @notice Pay for gas using native currency for an express contract call on a destination chain.
-     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
+     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
      * @param sender The address making the payment
      * @param destinationChain The target chain where the contract call will be made
      * @param destinationAddress The target address on the destination chain
@@ -282,7 +283,7 @@ interface IAxelarGasService is IUpgradable {
 
     /**
      * @notice Pay for gas using native currency for an express contract call with tokens on a destination chain.
-     * @dev This function is called on the source chain before calling the gateway to express execute a remote contract.
+     * @dev This function is called on the source chain before calling the gateway to execute a remote contract.
      * @param sender The address making the payment
      * @param destinationChain The target chain where the contract call with tokens will be made
      * @param destinationAddress The target address on the destination chain
@@ -361,6 +362,14 @@ interface IAxelarGasService is IUpgradable {
         address refundAddress
     ) external payable;
 
+    /**
+     * @notice Updates the gas price for a specific chain.
+     * @dev This function is called by the gas oracle to update the gas prices for a specific chains.
+     * @param chains Array of chain names
+     * @param gasUpdates Array of gas updates
+     */
+    function updateGasInfo(string[] calldata chains, GasInfo[] calldata gasUpdates) external;
+
     /**
      * @notice Allows the gasCollector to collect accumulated fees from the contract.
      * @dev Use address(0) as the token address for native currency.

contracts/interfaces/IGasEstimate.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title IAxelarGasService Interface
+ * @notice This is an interface for the AxelarGasService contract which manages gas payments
+ * and refunds for cross-chain communication on the Axelar network.
+ * @dev This interface inherits IUpgradable
+ */
+interface IGasEstimate {
+    error UnsupportedExtraFeeType(ExtraFeeType feeType);
+
+    /**
+     * @notice Event emitted when the gas price for a specific chain is updated.
+     * @param chain The name of the chain
+     * @param info The gas info for the chain
+     */
+    event GasInfoUpdated(string chain, GasInfo info);
+
+    enum ExtraFeeType {
+        None,
+        OptimismEcotone
+    }
+
+    struct GasInfo {
+        uint256 baseFee; // destination base_fee (in terms of src native gas token)
+        uint256 relativeGasPrice; // dest_gas_price * dest_token_market_price / src_token_market_price
+        ExtraFeeType extraFee; // additional fee type for L1 to L2
+    }
+
+    /**
+     * @notice Estimates the gas fee for a cross-chain contract call.
+     * @param destinationChain Axelar registered name of the destination chain
+     * @param destinationAddress Destination contract address being called
+     * @param executionGasLimit The gas limit to be used for the destination contract execution,
+     *        e.g. pass in 200k if your app consumes needs upto 200k for this contract call
+     * @return gasEstimate The cross-chain gas estimate, in terms of source chain's native gas token that should be forwarded to the gas service.
+     */
+    function estimateGasFee(
+        string calldata destinationChain,
+        string calldata destinationAddress,
+        bytes calldata payload,
+        uint256 executionGasLimit
+    ) external view returns (uint256 gasEstimate);
+}

contracts/test/gas/TestGasEstimate.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import { GasEstimate } from '../../gas/GasEstimate.sol';
+
+contract TestGasEstimate is GasEstimate {
+    constructor() {
+        if (GAS_SERVICE_SLOT != bytes32(uint256(keccak256("GasEstimate.Slot")) - 1)) {
+            revert("TestGasEstimate: invalid slot");
+        }
+    }
+
+    function updateGasInfo(string calldata chain, GasInfo calldata info) external {
+        _setGasInfo(chain, info);
+    }
+}

test/gas/GasEstimate.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const chai = require('chai');
+const { expect } = chai;
+const { ethers } = require('hardhat');
+
+describe('GasEstimate', () => {
+    let gasEstimateFactory;
+    let gasEstimate;
+
+    let ownerWallet;
+
+    const sourceChain = 'ethereum';
+    const destinationChain = 'optimism';
+
+    before(async () => {
+        [ownerWallet] = await ethers.getSigners();
+
+        gasEstimateFactory = await ethers.getContractFactory('TestGasEstimate', ownerWallet);
+        gasEstimate = await gasEstimateFactory.deploy().then((d) =>
+            d.deployed(),
+        );
+
+        await gasEstimate.updateGasInfo(sourceChain, [0, 50000000000, 0]);
+        await gasEstimate.updateGasInfo(destinationChain, [0, 50000000000, 1]);
+    });
+
+    describe('GasEstimate', () => {
+            it('should revert when deployed with empty gateway', async () => {
+                const estimate = await gasEstimate.estimateGasFee(destinationChain, destinationChain, '0x2534d1533c9ffce84d3174c1f846a4041d07b56d1e7b5cb7138e06fb42086325', 0);
+
+                expect(estimate).to.equal(352800000264);
+            });
+    });
+});