@hyperlane-xyz/core 1.2.0 → 1.2.2

package/README.md

@@ -1,14 +1,14 @@
-## Hyperlane Solidity
+# Hyperlane Solidity
 
 On-chain implementations of Hyperlane in Solidity.
 
-### Setup
+## Setup
 
 - `npm install --dev`
 - `brew install jq`   OR   `sudo apt-get install jq`
 - `npm install -g solhint`, check it is installed using `solhint --version`
 
-### Build
+## Build
 
 - `npm run compile`
 - `npm run test`

package/contracts/igps/InterchainGasPaymaster.sol

@@ -2,6 +2,7 @@
 pragma solidity >=0.8.0;
 
 // ============ Internal Imports ============
+import {IGasOracle} from "../../interfaces/IGasOracle.sol";
 import {IInterchainGasPaymaster} from "../../interfaces/IInterchainGasPaymaster.sol";
 // ============ External Imports ============
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
@@ -11,31 +12,63 @@ import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Own
  * @notice Manages payments on a source chain to cover gas costs of relaying
  * messages to destination chains.
  */
-contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
+contract InterchainGasPaymaster is
+    IInterchainGasPaymaster,
+    IGasOracle,
+    OwnableUpgradeable
+{
+    // ============ Constants ============
+
+    /// @notice The scale of gas oracle token exchange rates.
+    uint256 internal constant TOKEN_EXCHANGE_RATE_SCALE = 1e10;
+
+    // ============ Public Storage ============
+
+    /// @notice Keyed by remote domain, the gas oracle to use for the domain.
+    mapping(uint32 => IGasOracle) public gasOracles;
+
+    /// @notice The benficiary that can receive native tokens paid into this contract.
+    address public beneficiary;
+
     // ============ Events ============
 
     /**
-     * @notice Emitted when a payment is made for a message's gas costs.
-     * @param messageId The ID of the message to pay for.
-     * @param gasAmount The amount of destination gas paid for.
-     * @param payment The amount of native tokens paid.
+     * @notice Emitted when the gas oracle for a remote domain is set.
+     * @param remoteDomain The remote domain.
+     * @param gasOracle The gas oracle.
      */
-    event GasPayment(
-        bytes32 indexed messageId,
-        uint256 gasAmount,
-        uint256 payment
-    );
+    event GasOracleSet(uint32 indexed remoteDomain, address gasOracle);
+
+    /**
+     * @notice Emitted when the beneficiary is set.
+     * @param beneficiary The new beneficiary.
+     */
+    event BeneficiarySet(address beneficiary);
+
+    struct GasOracleConfig {
+        uint32 remoteDomain;
+        address gasOracle;
+    }
 
     // ============ Constructor ============
 
-    constructor() {
-        initialize(); // allows contract to be used without proxying
+    constructor(address _beneficiary) {
+        initialize(msg.sender, _beneficiary); // allows contract to be used without proxying
     }
 
     // ============ External Functions ============
 
-    function initialize() public initializer {
+    /**
+     * @param _owner The owner of the contract.
+     * @param _beneficiary The beneficiary.
+     */
+    function initialize(address _owner, address _beneficiary)
+        public
+        initializer
+    {
         __Ownable_init();
+        _transferOwnership(_owner);
+        _setBeneficiary(_beneficiary);
     }
 
     /**
@@ -45,8 +78,8 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
      * Callers should be aware that this may present reentrancy issues.
      * @param _messageId The ID of the message to pay for.
      * @param _destinationDomain The domain of the message's destination chain.
-     * @param _gasAmount The amount of destination gas to pay for. Currently unused.
-     * @param _refundAddress The address to refund any overpayment to. Currently unused.
+     * @param _gasAmount The amount of destination gas to pay for.
+     * @param _refundAddress The address to refund any overpayment to.
      */
     function payForGas(
         bytes32 _messageId,
@@ -68,13 +101,47 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
             require(_success, "Interchain gas payment refund failed");
         }
 
-        emit GasPayment(_messageId, _gasAmount, msg.value);
+        emit GasPayment(_messageId, _gasAmount, _requiredPayment);
+    }
+
+    /**
+     * @notice Transfers the entire native token balance to the beneficiary.
+     * @dev The beneficiary must be able to receive native tokens.
+     */
+    function claim() external {
+        // Transfer the entire balance to the beneficiary.
+        (bool success, ) = beneficiary.call{value: address(this).balance}("");
+        require(success, "!transfer");
     }
 
+    /**
+     * @notice Sets the gas oracles for remote domains specified in the config array.
+     * @param _configs An array of configs including the remote domain and gas oracles to set.
+     */
+    function setGasOracles(GasOracleConfig[] calldata _configs)
+        external
+        onlyOwner
+    {
+        uint256 _len = _configs.length;
+        for (uint256 i = 0; i < _len; i++) {
+            _setGasOracle(_configs[i].remoteDomain, _configs[i].gasOracle);
+        }
+    }
+
+    /**
+     * @notice Sets the beneficiary.
+     * @param _beneficiary The new beneficiary.
+     */
+    function setBeneficiary(address _beneficiary) external onlyOwner {
+        _setBeneficiary(_beneficiary);
+    }
+
+    // ============ Public Functions ============
+
     /**
      * @notice Quotes the amount of native tokens to pay for interchain gas.
      * @param _destinationDomain The domain of the message's destination chain.
-     * @param _gasAmount The amount of destination gas to pay for. Currently unused.
+     * @param _gasAmount The amount of destination gas to pay for.
      * @return The amount of native tokens required to pay for interchain gas.
      */
     function quoteGasPayment(uint32 _destinationDomain, uint256 _gasAmount)
@@ -84,21 +151,58 @@ contract InterchainGasPaymaster is IInterchainGasPaymaster, OwnableUpgradeable {
         override
         returns (uint256)
     {
-        // Silence compiler warning.
-        _destinationDomain;
-        _gasAmount;
-        // Charge a flat 1 wei fee.
-        // This is an intermediate step toward fully on-chain accurate gas payment quoting.
-        return 1;
+        // Get the gas data for the destination domain.
+        (
+            uint128 _tokenExchangeRate,
+            uint128 _gasPrice
+        ) = getExchangeRateAndGasPrice(_destinationDomain);
+
+        // The total cost quoted in destination chain's native token.
+        uint256 _destinationGasCost = _gasAmount * uint256(_gasPrice);
+
+        // Convert to the local native token.
+        return
+            (_destinationGasCost * _tokenExchangeRate) /
+            TOKEN_EXCHANGE_RATE_SCALE;
     }
 
     /**
-     * @notice Transfers the entire native token balance to the owner of the contract.
-     * @dev The owner must be able to receive native tokens.
+     * @notice Gets the token exchange rate and gas price from the configured gas oracle
+     * for a given destination domain.
+     * @param _destinationDomain The destination domain.
+     * @return tokenExchangeRate The exchange rate of the remote native token quoted in the local native token.
+     * @return gasPrice The gas price on the remote chain.
      */
-    function claim() external {
-        // Transfer the entire balance to owner.
-        (bool success, ) = owner().call{value: address(this).balance}("");
-        require(success, "!transfer");
+    function getExchangeRateAndGasPrice(uint32 _destinationDomain)
+        public
+        view
+        override
+        returns (uint128 tokenExchangeRate, uint128 gasPrice)
+    {
+        IGasOracle _gasOracle = gasOracles[_destinationDomain];
+        require(address(_gasOracle) != address(0), "!gas oracle");
+
+        return _gasOracle.getExchangeRateAndGasPrice(_destinationDomain);
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @notice Sets the beneficiary.
+     * @param _beneficiary The new beneficiary.
+     */
+    function _setBeneficiary(address _beneficiary) internal {
+        beneficiary = _beneficiary;
+        emit BeneficiarySet(_beneficiary);
+    }
+
+    /**
+     * @notice Sets the gas oracle for a remote domain.
+     * @param _remoteDomain The remote domain.
+     * @param _gasOracle The gas oracle.
+     */
+    function _setGasOracle(uint32 _remoteDomain, address _gasOracle) internal {
+        gasOracles[_remoteDomain] = IGasOracle(_gasOracle);
+        emit GasOracleSet(_remoteDomain, _gasOracle);
     }
 }

package/contracts/igps/gas-oracles/StorageGasOracle.sol

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IGasOracle} from "../../../interfaces/IGasOracle.sol";
+// ============ External Imports ============
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @notice A gas oracle that uses data stored within the contract.
+ * @dev This contract is intended to be owned by an address that will
+ * update the stored remote gas data.
+ */
+contract StorageGasOracle is IGasOracle, Ownable {
+    // ============ Public Storage ============
+
+    /// @notice Keyed by remote domain, gas data on that remote domain.
+    mapping(uint32 => IGasOracle.RemoteGasData) public remoteGasData;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when an entry in `remoteGasData` is set.
+     * @param remoteDomain The remote domain in which the gas data was set for.
+     * @param tokenExchangeRate The exchange rate of the remote native token quoted in the local native token.
+     * @param gasPrice The gas price on the remote chain.
+     */
+    event RemoteGasDataSet(
+        uint32 indexed remoteDomain,
+        uint128 tokenExchangeRate,
+        uint128 gasPrice
+    );
+
+    struct RemoteGasDataConfig {
+        uint32 remoteDomain;
+        uint128 tokenExchangeRate;
+        uint128 gasPrice;
+    }
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Returns the stored `remoteGasData` for the `_destinationDomain`.
+     * @param _destinationDomain The destination domain.
+     * @return tokenExchangeRate The exchange rate of the remote native token quoted in the local native token.
+     * @return gasPrice The gas price on the remote chain.
+     */
+    function getExchangeRateAndGasPrice(uint32 _destinationDomain)
+        external
+        view
+        override
+        returns (uint128 tokenExchangeRate, uint128 gasPrice)
+    {
+        // Intentionally allow unset / zero values
+        IGasOracle.RemoteGasData memory _data = remoteGasData[
+            _destinationDomain
+        ];
+        return (_data.tokenExchangeRate, _data.gasPrice);
+    }
+
+    /**
+     * @notice Sets the remote gas data for many remotes at a time.
+     * @param _configs The configs to use when setting the remote gas data.
+     */
+    function setRemoteGasDataConfigs(RemoteGasDataConfig[] calldata _configs)
+        external
+        onlyOwner
+    {
+        uint256 _len = _configs.length;
+        for (uint256 i = 0; i < _len; i++) {
+            _setRemoteGasData(_configs[i]);
+        }
+    }
+
+    /**
+     * @notice Sets the remote gas data using the values in `_config`.
+     * @param _config The config to use when setting the remote gas data.
+     */
+    function setRemoteGasData(RemoteGasDataConfig calldata _config)
+        external
+        onlyOwner
+    {
+        _setRemoteGasData(_config);
+    }
+
+    // ============ Internal functions ============
+
+    /**
+     * @notice Sets the remote gas data using the values in `_config`.
+     * @param _config The config to use when setting the remote gas data.
+     */
+    function _setRemoteGasData(RemoteGasDataConfig calldata _config) internal {
+        remoteGasData[_config.remoteDomain] = IGasOracle.RemoteGasData({
+            tokenExchangeRate: _config.tokenExchangeRate,
+            gasPrice: _config.gasPrice
+        });
+
+        emit RemoteGasDataSet(
+            _config.remoteDomain,
+            _config.tokenExchangeRate,
+            _config.gasPrice
+        );
+    }
+}

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -27,8 +27,8 @@ contract MockHyperlaneEnvironment {
         originMailbox.addRemoteMailbox(_destinationDomain, destinationMailbox);
         destinationMailbox.addRemoteMailbox(_originDomain, originMailbox);
 
-        igps[originDomain] = new TestInterchainGasPaymaster();
-        igps[destinationDomain] = new TestInterchainGasPaymaster();
+        igps[originDomain] = new TestInterchainGasPaymaster(address(this));
+        igps[destinationDomain] = new TestInterchainGasPaymaster(address(this));
 
         isms[originDomain] = new TestIsm();
         isms[destinationDomain] = new TestIsm();

package/contracts/test/LightTestRecipient.sol

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.6.11;
+
 import "./TestRecipient.sol";
 
 contract LightTestRecipient is TestRecipient {

package/contracts/test/TestInterchainGasPaymaster.sol

@@ -5,15 +5,14 @@ pragma solidity >=0.8.0;
 import {InterchainGasPaymaster} from "../igps/InterchainGasPaymaster.sol";
 
 contract TestInterchainGasPaymaster is InterchainGasPaymaster {
-    uint256 gasPrice = 0;
+    uint256 public constant gasPrice = 10;
 
-    function setGasPrice(uint256 _gasPrice) external {
-        gasPrice = _gasPrice;
-    }
+    // Ensure the same constructor interface as the inherited InterchainGasPaymaster
+    constructor(address _beneficiary) InterchainGasPaymaster(_beneficiary) {}
 
     function quoteGasPayment(uint32, uint256 gasAmount)
         public
-        view
+        pure
         override
         returns (uint256)
     {

package/dist/contracts/igps/InterchainGasPaymaster.d.ts

@@ -2,40 +2,85 @@ import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "../..
 import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import type { Listener, Provider } from "@ethersproject/providers";
 import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils } from "ethers";
+export declare namespace InterchainGasPaymaster {
+    type GasOracleConfigStruct = {
+        remoteDomain: BigNumberish;
+        gasOracle: string;
+    };
+    type GasOracleConfigStructOutput = [number, string] & {
+        remoteDomain: number;
+        gasOracle: string;
+    };
+}
 export interface InterchainGasPaymasterInterface extends utils.Interface {
     functions: {
+        "beneficiary()": FunctionFragment;
         "claim()": FunctionFragment;
-        "initialize()": FunctionFragment;
+        "gasOracles(uint32)": FunctionFragment;
+        "getExchangeRateAndGasPrice(uint32)": FunctionFragment;
+        "initialize(address,address)": FunctionFragment;
         "owner()": FunctionFragment;
         "payForGas(bytes32,uint32,uint256,address)": FunctionFragment;
         "quoteGasPayment(uint32,uint256)": FunctionFragment;
         "renounceOwnership()": FunctionFragment;
+        "setBeneficiary(address)": FunctionFragment;
+        "setGasOracles((uint32,address)[])": FunctionFragment;
         "transferOwnership(address)": FunctionFragment;
     };
-    getFunction(nameOrSignatureOrTopic: "claim" | "initialize" | "owner" | "payForGas" | "quoteGasPayment" | "renounceOwnership" | "transferOwnership"): FunctionFragment;
+    getFunction(nameOrSignatureOrTopic: "beneficiary" | "claim" | "gasOracles" | "getExchangeRateAndGasPrice" | "initialize" | "owner" | "payForGas" | "quoteGasPayment" | "renounceOwnership" | "setBeneficiary" | "setGasOracles" | "transferOwnership"): FunctionFragment;
+    encodeFunctionData(functionFragment: "beneficiary", values?: undefined): string;
     encodeFunctionData(functionFragment: "claim", values?: undefined): string;
-    encodeFunctionData(functionFragment: "initialize", values?: undefined): string;
+    encodeFunctionData(functionFragment: "gasOracles", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "getExchangeRateAndGasPrice", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [string, string]): string;
     encodeFunctionData(functionFragment: "owner", values?: undefined): string;
     encodeFunctionData(functionFragment: "payForGas", values: [BytesLike, BigNumberish, BigNumberish, string]): string;
     encodeFunctionData(functionFragment: "quoteGasPayment", values: [BigNumberish, BigNumberish]): string;
     encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setBeneficiary", values: [string]): string;
+    encodeFunctionData(functionFragment: "setGasOracles", values: [InterchainGasPaymaster.GasOracleConfigStruct[]]): string;
     encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
+    decodeFunctionResult(functionFragment: "beneficiary", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "gasOracles", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "getExchangeRateAndGasPrice", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "payForGas", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "quoteGasPayment", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setBeneficiary", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setGasOracles", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
     events: {
+        "BeneficiarySet(address)": EventFragment;
+        "GasOracleSet(uint32,address)": EventFragment;
         "GasPayment(bytes32,uint256,uint256)": EventFragment;
         "Initialized(uint8)": EventFragment;
         "OwnershipTransferred(address,address)": EventFragment;
     };
+    getEvent(nameOrSignatureOrTopic: "BeneficiarySet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "GasOracleSet"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "GasPayment"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
     getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
 }
+export interface BeneficiarySetEventObject {
+    beneficiary: string;
+}
+export declare type BeneficiarySetEvent = TypedEvent<[
+    string
+], BeneficiarySetEventObject>;
+export declare type BeneficiarySetEventFilter = TypedEventFilter<BeneficiarySetEvent>;
+export interface GasOracleSetEventObject {
+    remoteDomain: number;
+    gasOracle: string;
+}
+export declare type GasOracleSetEvent = TypedEvent<[
+    number,
+    string
+], GasOracleSetEventObject>;
+export declare type GasOracleSetEventFilter = TypedEventFilter<GasOracleSetEvent>;
 export interface GasPaymentEventObject {
     messageId: string;
     gasAmount: BigNumber;
@@ -76,10 +121,19 @@ export interface InterchainGasPaymaster extends BaseContract {
     once: OnEvent<this>;
     removeListener: OnEvent<this>;
     functions: {
+        beneficiary(overrides?: CallOverrides): Promise<[string]>;
         claim(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
-        initialize(overrides?: Overrides & {
+        gasOracles(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+        getExchangeRateAndGasPrice(_destinationDomain: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            tokenExchangeRate: BigNumber;
+            gasPrice: BigNumber;
+        }>;
+        initialize(_owner: string, _beneficiary: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
         owner(overrides?: CallOverrides): Promise<[string]>;
@@ -90,14 +144,29 @@ export interface InterchainGasPaymaster extends BaseContract {
         renounceOwnership(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
+        setBeneficiary(_beneficiary: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
+        setGasOracles(_configs: InterchainGasPaymaster.GasOracleConfigStruct[], overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<ContractTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<ContractTransaction>;
     };
+    beneficiary(overrides?: CallOverrides): Promise<string>;
     claim(overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
-    initialize(overrides?: Overrides & {
+    gasOracles(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    getExchangeRateAndGasPrice(_destinationDomain: BigNumberish, overrides?: CallOverrides): Promise<[
+        BigNumber,
+        BigNumber
+    ] & {
+        tokenExchangeRate: BigNumber;
+        gasPrice: BigNumber;
+    }>;
+    initialize(_owner: string, _beneficiary: string, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
     owner(overrides?: CallOverrides): Promise<string>;
@@ -108,19 +177,40 @@ export interface InterchainGasPaymaster extends BaseContract {
     renounceOwnership(overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
+    setBeneficiary(_beneficiary: string, overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
+    setGasOracles(_configs: InterchainGasPaymaster.GasOracleConfigStruct[], overrides?: Overrides & {
+        from?: string | Promise<string>;
+    }): Promise<ContractTransaction>;
     transferOwnership(newOwner: string, overrides?: Overrides & {
         from?: string | Promise<string>;
     }): Promise<ContractTransaction>;
     callStatic: {
+        beneficiary(overrides?: CallOverrides): Promise<string>;
         claim(overrides?: CallOverrides): Promise<void>;
-        initialize(overrides?: CallOverrides): Promise<void>;
+        gasOracles(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+        getExchangeRateAndGasPrice(_destinationDomain: BigNumberish, overrides?: CallOverrides): Promise<[
+            BigNumber,
+            BigNumber
+        ] & {
+            tokenExchangeRate: BigNumber;
+            gasPrice: BigNumber;
+        }>;
+        initialize(_owner: string, _beneficiary: string, overrides?: CallOverrides): Promise<void>;
         owner(overrides?: CallOverrides): Promise<string>;
         payForGas(_messageId: BytesLike, _destinationDomain: BigNumberish, _gasAmount: BigNumberish, _refundAddress: string, overrides?: CallOverrides): Promise<void>;
         quoteGasPayment(_destinationDomain: BigNumberish, _gasAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
         renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        setBeneficiary(_beneficiary: string, overrides?: CallOverrides): Promise<void>;
+        setGasOracles(_configs: InterchainGasPaymaster.GasOracleConfigStruct[], overrides?: CallOverrides): Promise<void>;
         transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
     };
     filters: {
+        "BeneficiarySet(address)"(beneficiary?: null): BeneficiarySetEventFilter;
+        BeneficiarySet(beneficiary?: null): BeneficiarySetEventFilter;
+        "GasOracleSet(uint32,address)"(remoteDomain?: BigNumberish | null, gasOracle?: null): GasOracleSetEventFilter;
+        GasOracleSet(remoteDomain?: BigNumberish | null, gasOracle?: null): GasOracleSetEventFilter;
         "GasPayment(bytes32,uint256,uint256)"(messageId?: BytesLike | null, gasAmount?: null, payment?: null): GasPaymentEventFilter;
         GasPayment(messageId?: BytesLike | null, gasAmount?: null, payment?: null): GasPaymentEventFilter;
         "Initialized(uint8)"(version?: null): InitializedEventFilter;
@@ -129,10 +219,13 @@ export interface InterchainGasPaymaster extends BaseContract {
         OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
     };
     estimateGas: {
+        beneficiary(overrides?: CallOverrides): Promise<BigNumber>;
         claim(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
-        initialize(overrides?: Overrides & {
+        gasOracles(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        getExchangeRateAndGasPrice(_destinationDomain: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(_owner: string, _beneficiary: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
         owner(overrides?: CallOverrides): Promise<BigNumber>;
@@ -143,15 +236,24 @@ export interface InterchainGasPaymaster extends BaseContract {
         renounceOwnership(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
+        setBeneficiary(_beneficiary: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
+        setGasOracles(_configs: InterchainGasPaymaster.GasOracleConfigStruct[], overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<BigNumber>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<BigNumber>;
     };
     populateTransaction: {
+        beneficiary(overrides?: CallOverrides): Promise<PopulatedTransaction>;
         claim(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;
-        initialize(overrides?: Overrides & {
+        gasOracles(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        getExchangeRateAndGasPrice(_destinationDomain: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(_owner: string, _beneficiary: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;
         owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
@@ -162,6 +264,12 @@ export interface InterchainGasPaymaster extends BaseContract {
         renounceOwnership(overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;
+        setBeneficiary(_beneficiary: string, overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
+        setGasOracles(_configs: InterchainGasPaymaster.GasOracleConfigStruct[], overrides?: Overrides & {
+            from?: string | Promise<string>;
+        }): Promise<PopulatedTransaction>;
         transferOwnership(newOwner: string, overrides?: Overrides & {
             from?: string | Promise<string>;
         }): Promise<PopulatedTransaction>;