diff --git a/contracts/src/v0.8/functions/v1_1_0/FunctionsBilling.sol b/contracts/src/v0.8/functions/v1_1_0/FunctionsBilling.sol
new file mode 100644
index 00000000000..ff345003741
--- /dev/null
+++ b/contracts/src/v0.8/functions/v1_1_0/FunctionsBilling.sol
@@ -0,0 +1,391 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {IFunctionsSubscriptions} from "../v1_0_0/interfaces/IFunctionsSubscriptions.sol";
+import {AggregatorV3Interface} from "../../shared/interfaces/AggregatorV3Interface.sol";
+import {IFunctionsBilling} from "../v1_0_0/interfaces/IFunctionsBilling.sol";
+
+import {Routable} from "../v1_0_0/Routable.sol";
+import {FunctionsResponse} from "../v1_0_0/libraries/FunctionsResponse.sol";
+
+import {SafeCast} from "../../vendor/openzeppelin-solidity/v4.8.3/contracts/utils/math/SafeCast.sol";
+
+import {ChainSpecificUtil} from "./libraries/ChainSpecificUtil.sol";
+
+/// @title Functions Billing contract
+/// @notice Contract that calculates payment from users to the nodes of the Decentralized Oracle Network (DON).
+abstract contract FunctionsBilling is Routable, IFunctionsBilling {
+  using FunctionsResponse for FunctionsResponse.RequestMeta;
+  using FunctionsResponse for FunctionsResponse.Commitment;
+  using FunctionsResponse for FunctionsResponse.FulfillResult;
+
+  uint256 private constant REASONABLE_GAS_PRICE_CEILING = 1_000_000_000_000_000; // 1 million gwei
+
+  event RequestBilled(
+    bytes32 indexed requestId,
+    uint96 juelsPerGas,
+    uint256 l1FeeShareWei,
+    uint96 callbackCostJuels,
+    uint96 totalCostJuels
+  );
+
+  // ================================================================
+  // |                  Request Commitment state                    |
+  // ================================================================
+
+  mapping(bytes32 requestId => bytes32 commitmentHash) private s_requestCommitments;
+
+  event CommitmentDeleted(bytes32 requestId);
+
+  // ================================================================
+  // |                     Configuration state                      |
+  // ================================================================
+
+  struct Config {
+    uint32 fulfillmentGasPriceOverEstimationBP; // ══╗ Percentage of gas price overestimation to account for changes in gas price between request and response. Held as basis points (one hundredth of 1 percentage point)
+    uint32 feedStalenessSeconds; //                  ║ How long before we consider the feed price to be stale and fallback to fallbackNativePerUnitLink.
+    uint32 gasOverheadBeforeCallback; //             ║ Represents the average gas execution cost before the fulfillment callback. This amount is always billed for every request.
+    uint32 gasOverheadAfterCallback; //              ║ Represents the average gas execution cost after the fulfillment callback. This amount is always billed for every request.
+    uint72 donFee; //                                ║ Additional flat fee (in Juels of LINK) that will be split between Node Operators. Max value is 2^80 - 1 == 1.2m LINK.
+    uint40 minimumEstimateGasPriceWei; //            ║ The lowest amount of wei that will be used as the tx.gasprice when estimating the cost to fulfill the request
+    uint16 maxSupportedRequestDataVersion; // ═══════╝ The highest support request data version supported by the node. All lower versions should also be supported.
+    uint224 fallbackNativePerUnitLink; // ═══════════╗ Fallback NATIVE CURRENCY / LINK conversion rate if the data feed is stale
+    uint32 requestTimeoutSeconds; // ════════════════╝ How many seconds it takes before we consider a request to be timed out
+  }
+
+  Config private s_config;
+
+  event ConfigUpdated(Config config);
+
+  error UnsupportedRequestDataVersion();
+  error InsufficientBalance();
+  error InvalidSubscription();
+  error UnauthorizedSender();
+  error MustBeSubOwner(address owner);
+  error InvalidLinkWeiPrice(int256 linkWei);
+  error PaymentTooLarge();
+  error NoTransmittersSet();
+  error InvalidCalldata();
+
+  // ================================================================
+  // |                        Balance state                         |
+  // ================================================================
+
+  mapping(address transmitter => uint96 balanceJuelsLink) private s_withdrawableTokens;
+  // Pool together collected DON fees
+  // Disperse them on withdrawal or change in OCR configuration
+  uint96 internal s_feePool;
+
+  AggregatorV3Interface private s_linkToNativeFeed;
+
+  // ================================================================
+  // |                       Initialization                         |
+  // ================================================================
+  constructor(address router, Config memory config, address linkToNativeFeed) Routable(router) {
+    s_linkToNativeFeed = AggregatorV3Interface(linkToNativeFeed);
+
+    updateConfig(config);
+  }
+
+  // ================================================================
+  // |                        Configuration                         |
+  // ================================================================
+
+  /// @notice Gets the Chainlink Coordinator's billing configuration
+  /// @return config
+  function getConfig() external view returns (Config memory) {
+    return s_config;
+  }
+
+  /// @notice Sets the Chainlink Coordinator's billing configuration
+  /// @param config - See the contents of the Config struct in IFunctionsBilling.Config for more information
+  function updateConfig(Config memory config) public {
+    _onlyOwner();
+
+    s_config = config;
+    emit ConfigUpdated(config);
+  }
+
+  // ================================================================
+  // |                       Fee Calculation                        |
+  // ================================================================
+
+  /// @inheritdoc IFunctionsBilling
+  function getDONFee(bytes memory /* requestData */) public view override returns (uint72) {
+    return s_config.donFee;
+  }
+
+  /// @inheritdoc IFunctionsBilling
+  function getAdminFee() public view override returns (uint72) {
+    return _getRouter().getAdminFee();
+  }
+
+  /// @inheritdoc IFunctionsBilling
+  function getWeiPerUnitLink() public view returns (uint256) {
+    Config memory config = s_config;
+    (, int256 weiPerUnitLink, , uint256 timestamp, ) = s_linkToNativeFeed.latestRoundData();
+    // solhint-disable-next-line not-rely-on-time
+    if (config.feedStalenessSeconds < block.timestamp - timestamp && config.feedStalenessSeconds > 0) {
+      return config.fallbackNativePerUnitLink;
+    }
+    if (weiPerUnitLink <= 0) {
+      revert InvalidLinkWeiPrice(weiPerUnitLink);
+    }
+    return uint256(weiPerUnitLink);
+  }
+
+  function _getJuelsFromWei(uint256 amountWei) private view returns (uint96) {
+    // (1e18 juels/link) * wei / (wei/link) = juels
+    // There are only 1e9*1e18 = 1e27 juels in existence, should not exceed uint96 (2^96 ~ 7e28)
+    return SafeCast.toUint96((1e18 * amountWei) / getWeiPerUnitLink());
+  }
+
+  // ================================================================
+  // |                       Cost Estimation                        |
+  // ================================================================
+
+  /// @inheritdoc IFunctionsBilling
+  function estimateCost(
+    uint64 subscriptionId,
+    bytes calldata data,
+    uint32 callbackGasLimit,
+    uint256 gasPriceWei
+  ) external view override returns (uint96) {
+    _getRouter().isValidCallbackGasLimit(subscriptionId, callbackGasLimit);
+    // Reasonable ceilings to prevent integer overflows
+    if (gasPriceWei > REASONABLE_GAS_PRICE_CEILING) {
+      revert InvalidCalldata();
+    }
+    uint72 adminFee = getAdminFee();
+    uint72 donFee = getDONFee(data);
+    return _calculateCostEstimate(callbackGasLimit, gasPriceWei, donFee, adminFee);
+  }
+
+  /// @notice Estimate the cost in Juels of LINK
+  // that will be charged to a subscription to fulfill a Functions request
+  // Gas Price can be overestimated to account for flucuations between request and response time
+  function _calculateCostEstimate(
+    uint32 callbackGasLimit,
+    uint256 gasPriceWei,
+    uint72 donFee,
+    uint72 adminFee
+  ) internal view returns (uint96) {
+    // If gas price is less than the minimum fulfillment gas price, override to using the minimum
+    if (gasPriceWei < s_config.minimumEstimateGasPriceWei) {
+      gasPriceWei = s_config.minimumEstimateGasPriceWei;
+    }
+
+    uint256 gasPriceWithOverestimation = gasPriceWei +
+      ((gasPriceWei * s_config.fulfillmentGasPriceOverEstimationBP) / 10_000);
+    /// @NOTE: Basis Points are 1/100th of 1%, divide by 10_000 to bring back to original units
+
+    uint256 executionGas = s_config.gasOverheadBeforeCallback + s_config.gasOverheadAfterCallback + callbackGasLimit;
+    uint256 l1FeeWei = ChainSpecificUtil._getCurrentTxL1GasFees(msg.data);
+    uint96 estimatedGasReimbursementJuels = _getJuelsFromWei((gasPriceWithOverestimation * executionGas) + l1FeeWei);
+
+    uint96 feesJuels = uint96(donFee) + uint96(adminFee);
+
+    return estimatedGasReimbursementJuels + feesJuels;
+  }
+
+  // ================================================================
+  // |                           Billing                            |
+  // ================================================================
+
+  /// @notice Initiate the billing process for an Functions request
+  /// @dev Only callable by the Functions Router
+  /// @param request - Chainlink Functions request data, see FunctionsResponse.RequestMeta for the structure
+  /// @return commitment - The parameters of the request that must be held consistent at response time
+  function _startBilling(
+    FunctionsResponse.RequestMeta memory request
+  ) internal returns (FunctionsResponse.Commitment memory commitment) {
+    Config memory config = s_config;
+
+    // Nodes should support all past versions of the structure
+    if (request.dataVersion > config.maxSupportedRequestDataVersion) {
+      revert UnsupportedRequestDataVersion();
+    }
+
+    uint72 donFee = getDONFee(request.data);
+    uint96 estimatedTotalCostJuels = _calculateCostEstimate(
+      request.callbackGasLimit,
+      tx.gasprice,
+      donFee,
+      request.adminFee
+    );
+
+    // Check that subscription can afford the estimated cost
+    if ((request.availableBalance) < estimatedTotalCostJuels) {
+      revert InsufficientBalance();
+    }
+
+    uint32 timeoutTimestamp = uint32(block.timestamp + config.requestTimeoutSeconds);
+    bytes32 requestId = keccak256(
+      abi.encode(
+        address(this),
+        request.requestingContract,
+        request.subscriptionId,
+        request.initiatedRequests + 1,
+        keccak256(request.data),
+        request.dataVersion,
+        request.callbackGasLimit,
+        estimatedTotalCostJuels,
+        timeoutTimestamp,
+        // solhint-disable-next-line avoid-tx-origin
+        tx.origin
+      )
+    );
+
+    commitment = FunctionsResponse.Commitment({
+      adminFee: request.adminFee,
+      coordinator: address(this),
+      client: request.requestingContract,
+      subscriptionId: request.subscriptionId,
+      callbackGasLimit: request.callbackGasLimit,
+      estimatedTotalCostJuels: estimatedTotalCostJuels,
+      timeoutTimestamp: timeoutTimestamp,
+      requestId: requestId,
+      donFee: donFee,
+      gasOverheadBeforeCallback: config.gasOverheadBeforeCallback,
+      gasOverheadAfterCallback: config.gasOverheadAfterCallback
+    });
+
+    s_requestCommitments[requestId] = keccak256(abi.encode(commitment));
+
+    return commitment;
+  }
+
+  /// @notice Finalize billing process for an Functions request by sending a callback to the Client contract and then charging the subscription
+  /// @param requestId identifier for the request that was generated by the Registry in the beginBilling commitment
+  /// @param response response data from DON consensus
+  /// @param err error from DON consensus
+  /// @param reportBatchSize the number of fulfillments in the transmitter's report
+  /// @return result fulfillment result
+  /// @dev Only callable by a node that has been approved on the Coordinator
+  /// @dev simulated offchain to determine if sufficient balance is present to fulfill the request
+  function _fulfillAndBill(
+    bytes32 requestId,
+    bytes memory response,
+    bytes memory err,
+    bytes memory onchainMetadata,
+    bytes memory /* offchainMetadata TODO: use in getDonFee() for dynamic billing */,
+    uint8 reportBatchSize
+  ) internal returns (FunctionsResponse.FulfillResult) {
+    FunctionsResponse.Commitment memory commitment = abi.decode(onchainMetadata, (FunctionsResponse.Commitment));
+
+    uint256 gasOverheadWei = (commitment.gasOverheadBeforeCallback + commitment.gasOverheadAfterCallback) * tx.gasprice;
+    uint256 l1FeeShareWei = ChainSpecificUtil._getCurrentTxL1GasFees(msg.data) / reportBatchSize;
+    // Gas overhead without callback
+    uint96 gasOverheadJuels = _getJuelsFromWei(gasOverheadWei + l1FeeShareWei);
+    uint96 juelsPerGas = _getJuelsFromWei(tx.gasprice);
+
+    // The Functions Router will perform the callback to the client contract
+    (FunctionsResponse.FulfillResult resultCode, uint96 callbackCostJuels) = _getRouter().fulfill(
+      response,
+      err,
+      juelsPerGas,
+      gasOverheadJuels + commitment.donFee, // cost without callback or admin fee, those will be added by the Router
+      msg.sender,
+      commitment
+    );
+
+    // The router will only pay the DON on successfully processing the fulfillment
+    // In these two fulfillment results the user has been charged
+    // Otherwise, the Coordinator should hold on to the request commitment
+    if (
+      resultCode == FunctionsResponse.FulfillResult.FULFILLED ||
+      resultCode == FunctionsResponse.FulfillResult.USER_CALLBACK_ERROR
+    ) {
+      delete s_requestCommitments[requestId];
+      // Reimburse the transmitter for the fulfillment gas cost
+      s_withdrawableTokens[msg.sender] = gasOverheadJuels + callbackCostJuels;
+      // Put donFee into the pool of fees, to be split later
+      // Saves on storage writes that would otherwise be charged to the user
+      s_feePool += commitment.donFee;
+      emit RequestBilled({
+        requestId: requestId,
+        juelsPerGas: juelsPerGas,
+        l1FeeShareWei: l1FeeShareWei,
+        callbackCostJuels: callbackCostJuels,
+        totalCostJuels: gasOverheadJuels + callbackCostJuels + commitment.donFee + commitment.adminFee
+      });
+    }
+
+    return resultCode;
+  }
+
+  // ================================================================
+  // |                       Request Timeout                        |
+  // ================================================================
+
+  /// @inheritdoc IFunctionsBilling
+  /// @dev Only callable by the Router
+  /// @dev Used by FunctionsRouter.sol during timeout of a request
+  function deleteCommitment(bytes32 requestId) external override onlyRouter {
+    // Delete commitment
+    delete s_requestCommitments[requestId];
+    emit CommitmentDeleted(requestId);
+  }
+
+  // ================================================================
+  // |                    Fund withdrawal                           |
+  // ================================================================
+
+  /// @inheritdoc IFunctionsBilling
+  function oracleWithdraw(address recipient, uint96 amount) external {
+    _disperseFeePool();
+
+    if (amount == 0) {
+      amount = s_withdrawableTokens[msg.sender];
+    } else if (s_withdrawableTokens[msg.sender] < amount) {
+      revert InsufficientBalance();
+    }
+    s_withdrawableTokens[msg.sender] -= amount;
+    IFunctionsSubscriptions(address(_getRouter())).oracleWithdraw(recipient, amount);
+  }
+
+  /// @inheritdoc IFunctionsBilling
+  /// @dev Only callable by the Coordinator owner
+  function oracleWithdrawAll() external {
+    _onlyOwner();
+    _disperseFeePool();
+
+    address[] memory transmitters = _getTransmitters();
+
+    // Bounded by "maxNumOracles" on OCR2Abstract.sol
+    for (uint256 i = 0; i < transmitters.length; ++i) {
+      uint96 balance = s_withdrawableTokens[transmitters[i]];
+      if (balance > 0) {
+        s_withdrawableTokens[transmitters[i]] = 0;
+        IFunctionsSubscriptions(address(_getRouter())).oracleWithdraw(transmitters[i], balance);
+      }
+    }
+  }
+
+  // Overriden in FunctionsCoordinator, which has visibility into transmitters
+  function _getTransmitters() internal view virtual returns (address[] memory);
+
+  // DON fees are collected into a pool s_feePool
+  // When OCR configuration changes, or any oracle withdraws, this must be dispersed
+  function _disperseFeePool() internal {
+    if (s_feePool == 0) {
+      return;
+    }
+    // All transmitters are assumed to also be observers
+    // Pay out the DON fee to all transmitters
+    address[] memory transmitters = _getTransmitters();
+    uint256 numberOfTransmitters = transmitters.length;
+    if (numberOfTransmitters == 0) {
+      revert NoTransmittersSet();
+    }
+    uint96 feePoolShare = s_feePool / uint96(numberOfTransmitters);
+    // Bounded by "maxNumOracles" on OCR2Abstract.sol
+    for (uint256 i = 0; i < numberOfTransmitters; ++i) {
+      s_withdrawableTokens[transmitters[i]] += feePoolShare;
+    }
+    s_feePool -= feePoolShare * uint96(numberOfTransmitters);
+  }
+
+  // Overriden in FunctionsCoordinator.sol
+  function _onlyOwner() internal view virtual;
+}
diff --git a/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol b/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol
new file mode 100644
index 00000000000..0a5da643a57
--- /dev/null
+++ b/contracts/src/v0.8/functions/v1_1_0/FunctionsCoordinator.sol
@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {IFunctionsCoordinator} from "../v1_0_0/interfaces/IFunctionsCoordinator.sol";
+import {ITypeAndVersion} from "../../shared/interfaces/ITypeAndVersion.sol";
+
+import {FunctionsBilling} from "./FunctionsBilling.sol";
+import {OCR2Base} from "./ocr/OCR2Base.sol";
+import {FunctionsResponse} from "../v1_0_0/libraries/FunctionsResponse.sol";
+
+/// @title Functions Coordinator contract
+/// @notice Contract that nodes of a Decentralized Oracle Network (DON) interact with
+contract FunctionsCoordinator is OCR2Base, IFunctionsCoordinator, FunctionsBilling {
+  using FunctionsResponse for FunctionsResponse.RequestMeta;
+  using FunctionsResponse for FunctionsResponse.Commitment;
+  using FunctionsResponse for FunctionsResponse.FulfillResult;
+
+  /// @inheritdoc ITypeAndVersion
+  // solhint-disable-next-line chainlink-solidity/all-caps-constant-storage-variables
+  string public constant override typeAndVersion = "Functions Coordinator v1.1.0";
+
+  event OracleRequest(
+    bytes32 indexed requestId,
+    address indexed requestingContract,
+    address requestInitiator,
+    uint64 subscriptionId,
+    address subscriptionOwner,
+    bytes data,
+    uint16 dataVersion,
+    bytes32 flags,
+    uint64 callbackGasLimit,
+    FunctionsResponse.Commitment commitment
+  );
+  event OracleResponse(bytes32 indexed requestId, address transmitter);
+
+  error InconsistentReportData();
+  error EmptyPublicKey();
+  error UnauthorizedPublicKeyChange();
+
+  bytes private s_donPublicKey;
+  bytes private s_thresholdPublicKey;
+
+  constructor(
+    address router,
+    Config memory config,
+    address linkToNativeFeed
+  ) OCR2Base() FunctionsBilling(router, config, linkToNativeFeed) {}
+
+  /// @inheritdoc IFunctionsCoordinator
+  function getThresholdPublicKey() external view override returns (bytes memory) {
+    if (s_thresholdPublicKey.length == 0) {
+      revert EmptyPublicKey();
+    }
+    return s_thresholdPublicKey;
+  }
+
+  /// @inheritdoc IFunctionsCoordinator
+  function setThresholdPublicKey(bytes calldata thresholdPublicKey) external override onlyOwner {
+    if (thresholdPublicKey.length == 0) {
+      revert EmptyPublicKey();
+    }
+    s_thresholdPublicKey = thresholdPublicKey;
+  }
+
+  /// @inheritdoc IFunctionsCoordinator
+  function getDONPublicKey() external view override returns (bytes memory) {
+    if (s_donPublicKey.length == 0) {
+      revert EmptyPublicKey();
+    }
+    return s_donPublicKey;
+  }
+
+  /// @inheritdoc IFunctionsCoordinator
+  function setDONPublicKey(bytes calldata donPublicKey) external override onlyOwner {
+    if (donPublicKey.length == 0) {
+      revert EmptyPublicKey();
+    }
+    s_donPublicKey = donPublicKey;
+  }
+
+  /// @dev check if node is in current transmitter list
+  function _isTransmitter(address node) internal view returns (bool) {
+    address[] memory nodes = s_transmitters;
+    // Bounded by "maxNumOracles" on OCR2Abstract.sol
+    for (uint256 i = 0; i < nodes.length; ++i) {
+      if (nodes[i] == node) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// @inheritdoc IFunctionsCoordinator
+  function startRequest(
+    FunctionsResponse.RequestMeta calldata request
+  ) external override onlyRouter returns (FunctionsResponse.Commitment memory commitment) {
+    commitment = _startBilling(request);
+
+    emit OracleRequest(
+      commitment.requestId,
+      request.requestingContract,
+      // solhint-disable-next-line avoid-tx-origin
+      tx.origin,
+      request.subscriptionId,
+      request.subscriptionOwner,
+      request.data,
+      request.dataVersion,
+      request.flags,
+      request.callbackGasLimit,
+      commitment
+    );
+
+    return commitment;
+  }
+
+  /// @dev DON fees are pooled together. If the OCR configuration is going to change, these need to be distributed.
+  function _beforeSetConfig(uint8 /* _f */, bytes memory /* _onchainConfig */) internal override {
+    if (_getTransmitters().length > 0) {
+      _disperseFeePool();
+    }
+  }
+
+  /// @dev Used by FunctionsBilling.sol
+  function _getTransmitters() internal view override returns (address[] memory) {
+    return s_transmitters;
+  }
+
+  /// @dev Report hook called within OCR2Base.sol
+  function _report(
+    uint256 /*initialGas*/,
+    address /*transmitter*/,
+    uint8 /*signerCount*/,
+    address[MAX_NUM_ORACLES] memory /*signers*/,
+    bytes calldata report
+  ) internal override {
+    (
+      bytes32[] memory requestIds,
+      bytes[] memory results,
+      bytes[] memory errors,
+      bytes[] memory onchainMetadata,
+      bytes[] memory offchainMetadata
+    ) = abi.decode(report, (bytes32[], bytes[], bytes[], bytes[], bytes[]));
+    uint256 numberOfFulfillments = uint8(requestIds.length);
+
+    if (
+      numberOfFulfillments == 0 ||
+      numberOfFulfillments != results.length ||
+      numberOfFulfillments != errors.length ||
+      numberOfFulfillments != onchainMetadata.length ||
+      numberOfFulfillments != offchainMetadata.length
+    ) {
+      revert ReportInvalid("Fields must be equal length");
+    }
+
+    // Bounded by "MaxRequestBatchSize" on the Job's ReportingPluginConfig
+    for (uint256 i = 0; i < numberOfFulfillments; ++i) {
+      FunctionsResponse.FulfillResult result = FunctionsResponse.FulfillResult(
+        _fulfillAndBill(
+          requestIds[i],
+          results[i],
+          errors[i],
+          onchainMetadata[i],
+          offchainMetadata[i],
+          uint8(numberOfFulfillments) // will not exceed "MaxRequestBatchSize" on the Job's ReportingPluginConfig
+        )
+      );
+
+      // Emit on successfully processing the fulfillment
+      // In these two fulfillment results the user has been charged
+      // Otherwise, the DON will re-try
+      if (
+        result == FunctionsResponse.FulfillResult.FULFILLED ||
+        result == FunctionsResponse.FulfillResult.USER_CALLBACK_ERROR
+      ) {
+        emit OracleResponse(requestIds[i], msg.sender);
+      }
+    }
+  }
+
+  /// @dev Used in FunctionsBilling.sol
+  function _onlyOwner() internal view override {
+    _validateOwnership();
+  }
+}
diff --git a/contracts/src/v0.8/functions/v1_1_0/libraries/ChainSpecificUtil.sol b/contracts/src/v0.8/functions/v1_1_0/libraries/ChainSpecificUtil.sol
new file mode 100644
index 00000000000..68d346e676d
--- /dev/null
+++ b/contracts/src/v0.8/functions/v1_1_0/libraries/ChainSpecificUtil.sol
@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {ArbGasInfo} from "../../../vendor/@arbitrum/nitro-contracts/src/precompiles/ArbGasInfo.sol";
+import {GasPriceOracle} from "../../../vendor/@eth-optimism/contracts-bedrock/v0.16.2/src/L2/GasPriceOracle.sol";
+
+/// @dev A library that abstracts out opcodes that behave differently across chains.
+/// @dev The methods below return values that are pertinent to the given chain.
+library ChainSpecificUtil {
+  // ------------ Start Arbitrum Constants ------------
+
+  /// @dev ARBGAS_ADDR is the address of the ArbGasInfo precompile on Arbitrum.
+  /// @dev reference: https://github.com/OffchainLabs/nitro/blob/v2.0.14/contracts/src/precompiles/ArbGasInfo.sol#L10
+  address private constant ARBGAS_ADDR = address(0x000000000000000000000000000000000000006C);
+  ArbGasInfo private constant ARBGAS = ArbGasInfo(ARBGAS_ADDR);
+
+  uint256 private constant ARB_MAINNET_CHAIN_ID = 42161;
+  uint256 private constant ARB_GOERLI_TESTNET_CHAIN_ID = 421613;
+  uint256 private constant ARB_SEPOLIA_TESTNET_CHAIN_ID = 421614;
+
+  // ------------ End Arbitrum Constants ------------
+
+  // ------------ Start Optimism Constants ------------
+  /// @dev L1_FEE_DATA_PADDING includes 35 bytes for L1 data padding for Optimism
+  bytes internal constant L1_FEE_DATA_PADDING =
+    "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
+  /// @dev OVM_GASPRICEORACLE_ADDR is the address of the GasPriceOracle precompile on Optimism.
+  /// @dev reference: https://community.optimism.io/docs/developers/build/transaction-fees/#estimating-the-l1-data-fee
+  address private constant OVM_GASPRICEORACLE_ADDR = address(0x420000000000000000000000000000000000000F);
+  GasPriceOracle private constant OVM_GASPRICEORACLE = GasPriceOracle(OVM_GASPRICEORACLE_ADDR);
+
+  uint256 private constant OP_MAINNET_CHAIN_ID = 10;
+  uint256 private constant OP_GOERLI_CHAIN_ID = 420;
+  uint256 private constant OP_SEPOLIA_CHAIN_ID = 11155420;
+
+  /// @dev Base is a OP stack based rollup and follows the same L1 pricing logic as Optimism.
+  uint256 private constant BASE_MAINNET_CHAIN_ID = 8453;
+  uint256 private constant BASE_GOERLI_CHAIN_ID = 84531;
+  uint256 private constant BASE_SEPOLIA_CHAIN_ID = 84532;
+
+  // ------------ End Optimism Constants ------------
+
+  /// @notice Returns the L1 fees in wei that will be paid for the current transaction, given any calldata
+  /// @notice for the current transaction.
+  /// @notice When on a known Arbitrum chain, it uses ArbGas.getCurrentTxL1GasFees to get the fees.
+  /// @notice On Arbitrum, the provided calldata is not used to calculate the fees.
+  /// @notice On Optimism, the provided calldata is passed to the GasPriceOracle predeploy
+  /// @notice and getL1Fee is called to get the fees.
+  function _getCurrentTxL1GasFees(bytes memory txCallData) internal view returns (uint256 l1FeeWei) {
+    uint256 chainid = block.chainid;
+    if (_isArbitrumChainId(chainid)) {
+      return ARBGAS.getCurrentTxL1GasFees();
+    } else if (_isOptimismChainId(chainid)) {
+      return OVM_GASPRICEORACLE.getL1Fee(bytes.concat(txCallData, L1_FEE_DATA_PADDING));
+    }
+    return 0;
+  }
+
+  /// @notice Return true if and only if the provided chain ID is an Arbitrum chain ID.
+  function _isArbitrumChainId(uint256 chainId) internal pure returns (bool) {
+    return
+      chainId == ARB_MAINNET_CHAIN_ID ||
+      chainId == ARB_GOERLI_TESTNET_CHAIN_ID ||
+      chainId == ARB_SEPOLIA_TESTNET_CHAIN_ID;
+  }
+
+  /// @notice Return true if and only if the provided chain ID is an Optimism (or Base) chain ID.
+  /// @notice Note that optimism chain id's are also OP stack chain id's.
+  function _isOptimismChainId(uint256 chainId) internal pure returns (bool) {
+    return
+      chainId == OP_MAINNET_CHAIN_ID ||
+      chainId == OP_GOERLI_CHAIN_ID ||
+      chainId == OP_SEPOLIA_CHAIN_ID ||
+      chainId == BASE_MAINNET_CHAIN_ID ||
+      chainId == BASE_GOERLI_CHAIN_ID ||
+      chainId == BASE_SEPOLIA_CHAIN_ID;
+  }
+}
diff --git a/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Abstract.sol b/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Abstract.sol
new file mode 100644
index 00000000000..4182227d645
--- /dev/null
+++ b/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Abstract.sol
@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {ITypeAndVersion} from "../../../shared/interfaces/ITypeAndVersion.sol";
+
+abstract contract OCR2Abstract is ITypeAndVersion {
+  // Maximum number of oracles the offchain reporting protocol is designed for
+  uint256 internal constant MAX_NUM_ORACLES = 31;
+
+  /**
+   * @notice triggers a new run of the offchain reporting protocol
+   * @param previousConfigBlockNumber block in which the previous config was set, to simplify historic analysis
+   * @param configDigest configDigest of this configuration
+   * @param configCount ordinal number of this config setting among all config settings over the life of this contract
+   * @param signers ith element is address ith oracle uses to sign a report
+   * @param transmitters ith element is address ith oracle uses to transmit a report via the transmit method
+   * @param f maximum number of faulty/dishonest oracles the protocol can tolerate while still working correctly
+   * @param onchainConfig serialized configuration used by the contract (and possibly oracles)
+   * @param offchainConfigVersion version of the serialization format used for "offchainConfig" parameter
+   * @param offchainConfig serialized configuration used by the oracles exclusively and only passed through the contract
+   */
+  event ConfigSet(
+    uint32 previousConfigBlockNumber,
+    bytes32 configDigest,
+    uint64 configCount,
+    address[] signers,
+    address[] transmitters,
+    uint8 f,
+    bytes onchainConfig,
+    uint64 offchainConfigVersion,
+    bytes offchainConfig
+  );
+
+  /**
+   * @notice sets offchain reporting protocol configuration incl. participating oracles
+   * @param signers addresses with which oracles sign the reports
+   * @param transmitters addresses oracles use to transmit the reports
+   * @param f number of faulty oracles the system can tolerate
+   * @param onchainConfig serialized configuration used by the contract (and possibly oracles)
+   * @param offchainConfigVersion version number for offchainEncoding schema
+   * @param offchainConfig serialized configuration used by the oracles exclusively and only passed through the contract
+   */
+  function setConfig(
+    address[] memory signers,
+    address[] memory transmitters,
+    uint8 f,
+    bytes memory onchainConfig,
+    uint64 offchainConfigVersion,
+    bytes memory offchainConfig
+  ) external virtual;
+
+  /**
+   * @notice information about current offchain reporting protocol configuration
+   * @return configCount ordinal number of current config, out of all configs applied to this contract so far
+   * @return blockNumber block at which this config was set
+   * @return configDigest domain-separation tag for current config (see _configDigestFromConfigData)
+   */
+  function latestConfigDetails()
+    external
+    view
+    virtual
+    returns (uint32 configCount, uint32 blockNumber, bytes32 configDigest);
+
+  /**
+    * @notice optionally emited to indicate the latest configDigest and epoch for
+     which a report was successfully transmited. Alternatively, the contract may
+     use latestConfigDigestAndEpoch with scanLogs set to false.
+  */
+  event Transmitted(bytes32 configDigest, uint32 epoch);
+
+  /**
+     * @notice optionally returns the latest configDigest and epoch for which a
+     report was successfully transmitted. Alternatively, the contract may return
+     scanLogs set to true and use Transmitted events to provide this information
+     to offchain watchers.
+   * @return scanLogs indicates whether to rely on the configDigest and epoch
+     returned or whether to scan logs for the Transmitted event instead.
+   * @return configDigest
+   * @return epoch
+   */
+  function latestConfigDigestAndEpoch()
+    external
+    view
+    virtual
+    returns (bool scanLogs, bytes32 configDigest, uint32 epoch);
+
+  /**
+   * @notice transmit is called to post a new report to the contract
+   * @param report serialized report, which the signatures are signing.
+   * @param rs ith element is the R components of the ith signature on report. Must have at most maxNumOracles entries
+   * @param ss ith element is the S components of the ith signature on report. Must have at most maxNumOracles entries
+   * @param rawVs ith element is the the V component of the ith signature
+   */
+  function transmit(
+    // NOTE: If these parameters are changed, expectedMsgDataLength and/or
+    // TRANSMIT_MSGDATA_CONSTANT_LENGTH_COMPONENT need to be changed accordingly
+    bytes32[3] calldata reportContext,
+    bytes calldata report,
+    bytes32[] calldata rs,
+    bytes32[] calldata ss,
+    bytes32 rawVs // signatures
+  ) external virtual;
+}
diff --git a/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Base.sol b/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Base.sol
new file mode 100644
index 00000000000..ea1d45ffd46
--- /dev/null
+++ b/contracts/src/v0.8/functions/v1_1_0/ocr/OCR2Base.sol
@@ -0,0 +1,351 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ConfirmedOwner} from "../../../shared/access/ConfirmedOwner.sol";
+import {OCR2Abstract} from "./OCR2Abstract.sol";
+
+/**
+ * @notice Onchain verification of reports from the offchain reporting protocol
+ * @dev For details on its operation, see the offchain reporting protocol design
+ * doc, which refers to this contract as simply the "contract".
+ */
+abstract contract OCR2Base is ConfirmedOwner, OCR2Abstract {
+  error ReportInvalid(string message);
+  error InvalidConfig(string message);
+
+  constructor() ConfirmedOwner(msg.sender) {}
+
+  // incremented each time a new config is posted. This count is incorporated
+  // into the config digest, to prevent replay attacks.
+  uint32 internal s_configCount;
+  uint32 internal s_latestConfigBlockNumber; // makes it easier for offchain systems
+  // to extract config from logs.
+
+  // Storing these fields used on the hot path in a ConfigInfo variable reduces the
+  // retrieval of all of them to a single SLOAD. If any further fields are
+  // added, make sure that storage of the struct still takes at most 32 bytes.
+  struct ConfigInfo {
+    bytes32 latestConfigDigest;
+    uint8 f; // TODO: could be optimized by squeezing into one slot
+    uint8 n;
+  }
+  ConfigInfo internal s_configInfo;
+
+  // Used for s_oracles[a].role, where a is an address, to track the purpose
+  // of the address, or to indicate that the address is unset.
+  enum Role {
+    // No oracle role has been set for address a
+    Unset,
+    // Signing address for the s_oracles[a].index'th oracle. I.e., report
+    // signatures from this oracle should ecrecover back to address a.
+    Signer,
+    // Transmission address for the s_oracles[a].index'th oracle. I.e., if a
+    // report is received by OCR2Aggregator.transmit in which msg.sender is
+    // a, it is attributed to the s_oracles[a].index'th oracle.
+    Transmitter
+  }
+
+  struct Oracle {
+    uint8 index; // Index of oracle in s_signers/s_transmitters
+    Role role; // Role of the address which mapped to this struct
+  }
+
+  mapping(address signerOrTransmitter => Oracle) internal s_oracles;
+
+  // s_signers contains the signing address of each oracle
+  address[] internal s_signers;
+
+  // s_transmitters contains the transmission address of each oracle,
+  // i.e. the address the oracle actually sends transactions to the contract from
+  address[] internal s_transmitters;
+
+  /*
+   * Config logic
+   */
+
+  // Reverts transaction if config args are invalid
+  modifier checkConfigValid(
+    uint256 numSigners,
+    uint256 numTransmitters,
+    uint256 f
+  ) {
+    if (numSigners > MAX_NUM_ORACLES) revert InvalidConfig("too many signers");
+    if (f == 0) revert InvalidConfig("f must be positive");
+    if (numSigners != numTransmitters) revert InvalidConfig("oracle addresses out of registration");
+    if (numSigners <= 3 * f) revert InvalidConfig("faulty-oracle f too high");
+    _;
+  }
+
+  struct SetConfigArgs {
+    address[] signers;
+    address[] transmitters;
+    uint8 f;
+    bytes onchainConfig;
+    uint64 offchainConfigVersion;
+    bytes offchainConfig;
+  }
+
+  /// @inheritdoc OCR2Abstract
+  function latestConfigDigestAndEpoch()
+    external
+    view
+    virtual
+    override
+    returns (bool scanLogs, bytes32 configDigest, uint32 epoch)
+  {
+    return (true, bytes32(0), uint32(0));
+  }
+
+  /**
+   * @notice sets offchain reporting protocol configuration incl. participating oracles
+   * @param _signers addresses with which oracles sign the reports
+   * @param _transmitters addresses oracles use to transmit the reports
+   * @param _f number of faulty oracles the system can tolerate
+   * @param _onchainConfig encoded on-chain contract configuration
+   * @param _offchainConfigVersion version number for offchainEncoding schema
+   * @param _offchainConfig encoded off-chain oracle configuration
+   */
+  function setConfig(
+    address[] memory _signers,
+    address[] memory _transmitters,
+    uint8 _f,
+    bytes memory _onchainConfig,
+    uint64 _offchainConfigVersion,
+    bytes memory _offchainConfig
+  ) external override checkConfigValid(_signers.length, _transmitters.length, _f) onlyOwner {
+    SetConfigArgs memory args = SetConfigArgs({
+      signers: _signers,
+      transmitters: _transmitters,
+      f: _f,
+      onchainConfig: _onchainConfig,
+      offchainConfigVersion: _offchainConfigVersion,
+      offchainConfig: _offchainConfig
+    });
+
+    _beforeSetConfig(args.f, args.onchainConfig);
+
+    while (s_signers.length != 0) {
+      // remove any old signer/transmitter addresses
+      uint256 lastIdx = s_signers.length - 1;
+      address signer = s_signers[lastIdx];
+      address transmitter = s_transmitters[lastIdx];
+      delete s_oracles[signer];
+      delete s_oracles[transmitter];
+      s_signers.pop();
+      s_transmitters.pop();
+    }
+
+    // Bounded by MAX_NUM_ORACLES in OCR2Abstract.sol
+    for (uint256 i = 0; i < args.signers.length; i++) {
+      if (args.signers[i] == address(0)) revert InvalidConfig("signer must not be empty");
+      if (args.transmitters[i] == address(0)) revert InvalidConfig("transmitter must not be empty");
+      // add new signer/transmitter addresses
+      if (s_oracles[args.signers[i]].role != Role.Unset) revert InvalidConfig("repeated signer address");
+      s_oracles[args.signers[i]] = Oracle(uint8(i), Role.Signer);
+      if (s_oracles[args.transmitters[i]].role != Role.Unset) revert InvalidConfig("repeated transmitter address");
+      s_oracles[args.transmitters[i]] = Oracle(uint8(i), Role.Transmitter);
+      s_signers.push(args.signers[i]);
+      s_transmitters.push(args.transmitters[i]);
+    }
+    s_configInfo.f = args.f;
+    uint32 previousConfigBlockNumber = s_latestConfigBlockNumber;
+    s_latestConfigBlockNumber = uint32(block.number);
+    s_configCount += 1;
+    {
+      s_configInfo.latestConfigDigest = _configDigestFromConfigData(
+        block.chainid,
+        address(this),
+        s_configCount,
+        args.signers,
+        args.transmitters,
+        args.f,
+        args.onchainConfig,
+        args.offchainConfigVersion,
+        args.offchainConfig
+      );
+    }
+    s_configInfo.n = uint8(args.signers.length);
+
+    emit ConfigSet(
+      previousConfigBlockNumber,
+      s_configInfo.latestConfigDigest,
+      s_configCount,
+      args.signers,
+      args.transmitters,
+      args.f,
+      args.onchainConfig,
+      args.offchainConfigVersion,
+      args.offchainConfig
+    );
+  }
+
+  function _configDigestFromConfigData(
+    uint256 _chainId,
+    address _contractAddress,
+    uint64 _configCount,
+    address[] memory _signers,
+    address[] memory _transmitters,
+    uint8 _f,
+    bytes memory _onchainConfig,
+    uint64 _encodedConfigVersion,
+    bytes memory _encodedConfig
+  ) internal pure returns (bytes32) {
+    uint256 h = uint256(
+      keccak256(
+        abi.encode(
+          _chainId,
+          _contractAddress,
+          _configCount,
+          _signers,
+          _transmitters,
+          _f,
+          _onchainConfig,
+          _encodedConfigVersion,
+          _encodedConfig
+        )
+      )
+    );
+    uint256 prefixMask = type(uint256).max << (256 - 16); // 0xFFFF00..00
+    uint256 prefix = 0x0001 << (256 - 16); // 0x000100..00
+    return bytes32((prefix & prefixMask) | (h & ~prefixMask));
+  }
+
+  /**
+   * @notice information about current offchain reporting protocol configuration
+   * @return configCount ordinal number of current config, out of all configs applied to this contract so far
+   * @return blockNumber block at which this config was set
+   * @return configDigest domain-separation tag for current config (see __configDigestFromConfigData)
+   */
+  function latestConfigDetails()
+    external
+    view
+    override
+    returns (uint32 configCount, uint32 blockNumber, bytes32 configDigest)
+  {
+    return (s_configCount, s_latestConfigBlockNumber, s_configInfo.latestConfigDigest);
+  }
+
+  /**
+   * @return list of addresses permitted to transmit reports to this contract
+   * @dev The list will match the order used to specify the transmitter during setConfig
+   */
+  function transmitters() external view returns (address[] memory) {
+    return s_transmitters;
+  }
+
+  function _beforeSetConfig(uint8 _f, bytes memory _onchainConfig) internal virtual;
+
+  /**
+   * @dev hook called after the report has been fully validated
+   * for the extending contract to handle additional logic, such as oracle payment
+   * @param initialGas the amount of gas before validation
+   * @param transmitter the address of the account that submitted the report
+   * @param signers the addresses of all signing accounts
+   * @param report serialized report
+   */
+  function _report(
+    uint256 initialGas,
+    address transmitter,
+    uint8 signerCount,
+    address[MAX_NUM_ORACLES] memory signers,
+    bytes calldata report
+  ) internal virtual;
+
+  // The constant-length components of the msg.data sent to transmit.
+  // See the "If we wanted to call sam" example on for example reasoning
+  // https://solidity.readthedocs.io/en/v0.7.2/abi-spec.html
+  uint16 private constant TRANSMIT_MSGDATA_CONSTANT_LENGTH_COMPONENT =
+    4 + // function selector
+      32 *
+      3 + // 3 words containing reportContext
+      32 + // word containing start location of abiencoded report value
+      32 + // word containing location start of abiencoded rs value
+      32 + // word containing start location of abiencoded ss value
+      32 + // rawVs value
+      32 + // word containing length of report
+      32 + // word containing length rs
+      32 + // word containing length of ss
+      0; // placeholder
+
+  function _requireExpectedMsgDataLength(
+    bytes calldata report,
+    bytes32[] calldata rs,
+    bytes32[] calldata ss
+  ) private pure {
+    // calldata will never be big enough to make this overflow
+    uint256 expected = uint256(TRANSMIT_MSGDATA_CONSTANT_LENGTH_COMPONENT) +
+      report.length + // one byte pure entry in _report
+      rs.length *
+      32 + // 32 bytes per entry in _rs
+      ss.length *
+      32 + // 32 bytes per entry in _ss
+      0; // placeholder
+    if (msg.data.length != expected) revert ReportInvalid("calldata length mismatch");
+  }
+
+  /**
+   * @notice transmit is called to post a new report to the contract
+   * @param report serialized report, which the signatures are signing.
+   * @param rs ith element is the R components of the ith signature on report. Must have at most maxNumOracles entries
+   * @param ss ith element is the S components of the ith signature on report. Must have at most maxNumOracles entries
+   * @param rawVs ith element is the the V component of the ith signature
+   */
+  function transmit(
+    // NOTE: If these parameters are changed, expectedMsgDataLength and/or
+    // TRANSMIT_MSGDATA_CONSTANT_LENGTH_COMPONENT need to be changed accordingly
+    bytes32[3] calldata reportContext,
+    bytes calldata report,
+    bytes32[] calldata rs,
+    bytes32[] calldata ss,
+    bytes32 rawVs // signatures
+  ) external override {
+    uint256 initialGas = gasleft(); // This line must come first
+
+    {
+      // reportContext consists of:
+      // reportContext[0]: ConfigDigest
+      // reportContext[1]: 27 byte padding, 4-byte epoch and 1-byte round
+      // reportContext[2]: ExtraHash
+      bytes32 configDigest = reportContext[0];
+      uint32 epochAndRound = uint32(uint256(reportContext[1]));
+
+      emit Transmitted(configDigest, uint32(epochAndRound >> 8));
+
+      // The following check is disabled to allow both current and proposed routes to submit reports using the same OCR config digest
+      // Chainlink Functions uses globally unique request IDs. Metadata about the request is stored and checked in the Coordinator and Router
+      // require(configInfo.latestConfigDigest == configDigest, "configDigest mismatch");
+
+      _requireExpectedMsgDataLength(report, rs, ss);
+
+      uint256 expectedNumSignatures = (s_configInfo.n + s_configInfo.f) / 2 + 1;
+
+      if (rs.length != expectedNumSignatures) revert ReportInvalid("wrong number of signatures");
+      if (rs.length != ss.length) revert ReportInvalid("report rs and ss must be of equal length");
+
+      Oracle memory transmitter = s_oracles[msg.sender];
+      if (transmitter.role != Role.Transmitter && msg.sender != s_transmitters[transmitter.index])
+        revert ReportInvalid("unauthorized transmitter");
+    }
+
+    address[MAX_NUM_ORACLES] memory signed;
+    uint8 signerCount = 0;
+
+    {
+      // Verify signatures attached to report
+      bytes32 h = keccak256(abi.encodePacked(keccak256(report), reportContext));
+
+      Oracle memory o;
+      // Bounded by MAX_NUM_ORACLES in OCR2Abstract.sol
+      for (uint256 i = 0; i < rs.length; ++i) {
+        address signer = ecrecover(h, uint8(rawVs[i]) + 27, rs[i], ss[i]);
+        o = s_oracles[signer];
+        if (o.role != Role.Signer) revert ReportInvalid("address not authorized to sign");
+        if (signed[o.index] != address(0)) revert ReportInvalid("non-unique signature");
+        signed[o.index] = signer;
+        signerCount += 1;
+      }
+    }
+
+    _report(initialGas, msg.sender, signerCount, signed, report);
+  }
+}