Phase 1

FunctionSignatures.md

@@ -479,7 +479,7 @@
 | `setRequestPayloadCountLimit`  | `0x8526582b` |
 | `submitRequest`                | `0xf91ba7cc` |
 | `transferOwnership`            | `0xf2fde38b` |
-| `updateRequestAndProcessBatch` | `0x46464471` |
+| `updateRequest` | `0x46464471` |
 | `watcher__`                    | `0x300bb063` |
 
 ## Watcher

contracts/evmx/fees/Credit.sol

@@ -10,11 +10,10 @@ import "solady/tokens/ERC20.sol";
 import "../interfaces/IFeesManager.sol";
 import "../interfaces/IFeesPlug.sol";
 import "../interfaces/IFeesPool.sol";
-import "../interfaces/IReceiver.sol";
 
 import {AddressResolverUtil} from "../helpers/AddressResolverUtil.sol";
 import {NonceUsed, InvalidAmount, InsufficientCreditsAvailable, InsufficientBalance, InvalidChainSlug, NotRequestHandler, InvalidReceiver} from "../../utils/common/Errors.sol";
-import {WRITE} from "../../utils/common/Constants.sol";
+import {WRITE, FAST} from "../../utils/common/Constants.sol";
 import "../../utils/RescueFundsLib.sol";
 import "../base/AppGatewayBase.sol";
 import {toBytes32Format} from "../../utils/common/Converters.sol";
@@ -34,9 +33,9 @@ abstract contract FeesManagerStorage is IFeesManager {
     mapping(address => uint256) public userBlockedCredits;
 
     // slot 52
-    /// @notice Mapping to track request credits details for each request count
-    /// @dev requestCount => RequestFee
-    mapping(uint40 => uint256) public requestBlockedCredits;
+    /// @notice Mapping to track request credits details for each payload id
+    /// @dev payloadId => RequestFee
+    mapping(bytes32 => uint256) public requestBlockedCredits;
 
     // slot 53
     // token pool balances
@@ -136,7 +135,6 @@ abstract contract Credit is FeesManagerStorage, Initializable, Ownable, AppGatew
 
         // Mint tokens to the user
         _mint(depositTo_, creditAmount_);
-
         if (nativeAmount_ > 0) {
             // if native transfer fails, add to credit
             bool success = feesPool.withdraw(depositTo_, nativeAmount_);
@@ -201,7 +199,7 @@ abstract contract Credit is FeesManagerStorage, Initializable, Ownable, AppGatew
         uint256 amount_
     ) public view override returns (bool) {
         // If consumeFrom_ is not same as spender_ or spender_ is not watcher, check if it is approved
-        if (!_isWatcher(spender_) && consumeFrom_ != spender_) {
+        if (spender_ != address(watcher__()) && consumeFrom_ != spender_) {
             if (allowance(consumeFrom_, spender_) == 0) return false;
         }
 
@@ -224,7 +222,7 @@ abstract contract Credit is FeesManagerStorage, Initializable, Ownable, AppGatew
     ) public override returns (bool) {
         if (!isCreditSpendable(from_, msg.sender, amount_)) revert InsufficientCreditsAvailable();
 
-        if (_isWatcher(msg.sender)) _approve(from_, msg.sender, amount_);
+        if (msg.sender == address(watcher__())) _approve(from_, msg.sender, amount_);
         return super.transferFrom(from_, to_, amount_);
     }
 
@@ -268,33 +266,28 @@ abstract contract Credit is FeesManagerStorage, Initializable, Ownable, AppGatew
         uint256 maxFees_,
         bytes memory payload_
     ) internal async {
-        _setMaxFees(getMaxFees(chainSlug_));
-        _setOverrides(consumeFrom_);
-
-        QueueParams memory queueParams;
-        queueParams.overrideParams = overrideParams;
-        queueParams.transaction = Transaction({
+        // applyOverride(
+        //     OverrideParamsLib.setMaxFees(overrideParams, getMaxFees(chainSlug_)).setConsumeFrom(consumeFrom_)
+        // );
+        RawPayload memory rawPayload;
+        rawPayload.overrideParams = overrideParams;
+        rawPayload.transaction = Transaction({
             chainSlug: chainSlug_,
             target: _getFeesPlugAddress(chainSlug_),
             payload: payload_
         });
-        queueParams.switchboardType = sbType;
-        watcher__().queue(queueParams, address(this));
+        watcher__().executePayload(rawPayload, address(this));
     }
 
-    function increaseFees(uint40 requestCount_, uint256 newMaxFees_) public {
-        _increaseFees(requestCount_, newMaxFees_);
+    function increaseFees(bytes32 payloadId_, uint256 newMaxFees_) public {
+        _increaseFees(payloadId_, newMaxFees_);
     }
 
     function _getFeesPlugAddress(uint32 chainSlug_) internal view returns (bytes32) {
         if (feesPlugs[chainSlug_] == bytes32(0)) revert InvalidChainSlug();
         return feesPlugs[chainSlug_];
     }
 
-    function _getRequestParams(uint40 requestCount_) internal view returns (RequestParams memory) {
-        return watcher__().getRequestParams(requestCount_);
-    }
-
     function _recoverSigner(
         bytes32 digest_,
         bytes memory signature_

contracts/evmx/fees/FeesManager.sol

@@ -6,19 +6,21 @@ import "./Credit.sol";
 /// @title FeesManager
 /// @notice Contract for managing fees
 contract FeesManager is Credit {
+    using OverrideParamsLib for OverrideParams;
+
     /// @notice Emitted when fees are blocked for a batch
-    /// @param requestCount The batch identifier
+    /// @param payloadId The payload id
     /// @param consumeFrom The consume from address
     /// @param amount The blocked amount
-    event CreditsBlocked(uint40 indexed requestCount, address indexed consumeFrom, uint256 amount);
+    event CreditsBlocked(bytes32 indexed payloadId, address indexed consumeFrom, uint256 amount);
 
     /// @notice Emitted when fees are unblocked and assigned to a transmitter
-    /// @param requestCount The batch identifier
+    /// @param payloadId The payload id
     /// @param consumeFrom The consume from address
     /// @param transmitter The transmitter address
     /// @param amount The unblocked amount
     event CreditsUnblockedAndAssigned(
-        uint40 indexed requestCount,
+        bytes32 indexed payloadId,
         address indexed consumeFrom,
         address indexed transmitter,
         uint256 amount
@@ -30,14 +32,9 @@ contract FeesManager is Credit {
     event MaxFeesPerChainSlugSet(uint32 indexed chainSlug, uint256 fees);
 
     /// @notice Emitted when fees are unblocked
-    /// @param requestCount The batch identifier
+    /// @param payloadId The payload id
     /// @param consumeFrom The consume from address
-    event CreditsUnblocked(uint40 indexed requestCount, address indexed consumeFrom);
-
-    modifier onlyRequestHandler() {
-        if (msg.sender != address(watcher__().requestHandler__())) revert NotRequestHandler();
-        _;
-    }
+    event CreditsUnblocked(bytes32 indexed payloadId, address indexed consumeFrom);
 
     constructor() {
         _disableInitializers(); // disable for implementation
@@ -56,11 +53,10 @@ contract FeesManager is Credit {
         bytes32 sbType_
     ) public reinitializer(2) {
         evmxSlug = evmxSlug_;
-        sbType = sbType_;
         feesPool = IFeesPool(feesPool_);
         maxFeesPerChainSlug[evmxSlug_] = fees_;
-
-        _setMaxFees(fees_);
+        overrideParams = overrideParams.setSwitchboardType(sbType_).setMaxFees(fees_);
+
         _initializeOwner(owner_);
         _initializeAppGateway(addressResolver_);
     }
@@ -88,39 +84,40 @@ contract FeesManager is Credit {
     }
 
     function setMaxFees(uint256 fees_) external onlyOwner {
-        _setMaxFees(fees_);
+        overrideParams = overrideParams.setMaxFees(fees_);
     }
 
     /////////////////////// FEES MANAGEMENT ///////////////////////
 
     /// @notice Blocks fees for a request count
-    /// @param requestCount_ The batch identifier
+    /// @param payloadId_ The payload id
     /// @param consumeFrom_ The fees payer address
     /// @param credits_ The total fees to block
     /// @dev Only callable by delivery helper
     function blockCredits(
-        uint40 requestCount_,
+        bytes32 payloadId_,
         address consumeFrom_,
         uint256 credits_
-    ) external override onlyRequestHandler {
+    ) external override onlyWatcher {
         if (balanceOf(consumeFrom_) < credits_) revert InsufficientCreditsAvailable();
 
         userBlockedCredits[consumeFrom_] += credits_;
-        requestBlockedCredits[requestCount_] = credits_;
-        emit CreditsBlocked(requestCount_, consumeFrom_, credits_);
+        requestBlockedCredits[payloadId_] = credits_;
+        emit CreditsBlocked(payloadId_, consumeFrom_, credits_);
     }
 
     /// @notice Unblocks fees after successful execution and assigns them to the transmitter
-    /// @param requestCount_ The request count of the executed batch
+    /// @param payloadId_ The payload id
     /// @param assignTo_ The address of the transmitter
     function unblockAndAssignCredits(
-        uint40 requestCount_,
+        bytes32 payloadId_,
         address assignTo_
-    ) external override onlyRequestHandler {
-        uint256 blockedCredits = requestBlockedCredits[requestCount_];
+    ) external override onlyWatcher {
+        uint256 blockedCredits = requestBlockedCredits[payloadId_];
         if (blockedCredits == 0) return;
 
-        address consumeFrom = _getRequestParams(requestCount_).requestFeesDetails.consumeFrom;
+        // address consumeFrom = _getRequestParams(requestCount_).requestFeesDetails.consumeFrom;
+        address consumeFrom = overrideParams.consumeFrom;
 
         // Unblock credits from the original user
         userBlockedCredits[consumeFrom] -= blockedCredits;
@@ -132,20 +129,21 @@ contract FeesManager is Credit {
         _mint(assignTo_, blockedCredits);
 
         // Clean up storage
-        delete requestBlockedCredits[requestCount_];
-        emit CreditsUnblockedAndAssigned(requestCount_, consumeFrom, assignTo_, blockedCredits);
+        delete requestBlockedCredits[payloadId_];
+        emit CreditsUnblockedAndAssigned(payloadId_, consumeFrom, assignTo_, blockedCredits);
     }
 
-    function unblockCredits(uint40 requestCount_) external override onlyRequestHandler {
-        uint256 blockedCredits = requestBlockedCredits[requestCount_];
+    function unblockCredits(bytes32 payloadId_) external override onlyWatcher {
+        uint256 blockedCredits = requestBlockedCredits[payloadId_];
         if (blockedCredits == 0) return;
 
         // Unblock credits from the original user
-        address consumeFrom = _getRequestParams(requestCount_).requestFeesDetails.consumeFrom;
+        // address consumeFrom = _getRequestParams(requestCount_).requestFeesDetails.consumeFrom;
+        address consumeFrom = overrideParams.consumeFrom;
         userBlockedCredits[consumeFrom] -= blockedCredits;
 
-        delete requestBlockedCredits[requestCount_];
-        emit CreditsUnblocked(requestCount_, consumeFrom);
+        delete requestBlockedCredits[payloadId_];
+        emit CreditsUnblocked(payloadId_, consumeFrom);
     }
 
     /**

contracts/evmx/helpers/AddressResolver.sol

@@ -20,11 +20,6 @@ abstract contract AddressResolverStorage is IAddressResolver {
     // slot 52
     IAsyncDeployer public override asyncDeployer__;
 
-    // slot 53
-    IDeployForwarder public override deployForwarder__;
-
-    // slot 54
-    address public override defaultAuctionManager;
 
     // slot 55
     mapping(bytes32 => address) public override contractAddresses;
@@ -75,20 +70,6 @@ contract AddressResolver is AddressResolverStorage, Initializable, Ownable {
         emit AsyncDeployerUpdated(asyncDeployer_);
     }
 
-    /// @notice Updates the address of the default auction manager
-    /// @param defaultAuctionManager_ The address of the default auction manager
-    function setDefaultAuctionManager(address defaultAuctionManager_) external override onlyOwner {
-        defaultAuctionManager = defaultAuctionManager_;
-        emit DefaultAuctionManagerUpdated(defaultAuctionManager_);
-    }
-
-    /// @notice Updates the address of the deploy forwarder
-    /// @param deployForwarder_ The address of the deploy forwarder
-    function setDeployForwarder(address deployForwarder_) external override onlyOwner {
-        deployForwarder__ = IDeployForwarder(deployForwarder_);
-        emit DeployForwarderUpdated(deployForwarder_);
-    }
-
     /// @notice Updates the address of a contract
     /// @param contractId_ The id of the contract
     /// @param contractAddress_ The address of the contract

contracts/evmx/helpers/AddressResolverUtil.sol

@@ -22,12 +22,13 @@ abstract contract AddressResolverUtil {
     /// @notice Restricts function access to the watcher precompile contract
     /// @dev Validates that msg.sender matches the registered watcher precompile address
     modifier onlyWatcher() {
-        if (!_isWatcher(msg.sender)) revert OnlyWatcherAllowed();
+        if (!isWatcher()) revert OnlyWatcherAllowed();
         _;
     }
 
-    function _isWatcher(address account_) internal view returns (bool) {
-        return (watcher__().isWatcher(account_) || account_ == address(watcher__()));
+    /// @notice Restricts function access to the watcher owner
+    function isWatcher() internal view returns (bool) {
+        return msg.sender == address(watcher__()) || msg.sender == watcher__().owner();
     }
 
     /// @notice Gets the watcher precompile contract interface
@@ -51,13 +52,6 @@ abstract contract AddressResolverUtil {
         return addressResolver__.asyncDeployer__();
     }
 
-    /// @notice Gets the deploy forwarder contract interface
-    /// @return IDeployForwarder interface of the registered deploy forwarder
-    /// @dev Resolves and returns the deploy forwarder contract for interaction
-    function deployForwarder__() public view returns (IDeployForwarder) {
-        return addressResolver__.deployForwarder__();
-    }
-
     /// @notice Internal function to set the address resolver
     /// @param _addressResolver The address of the resolver contract
     /// @dev Should be called in the initialization of inheriting contracts

contracts/evmx/helpers/AsyncDeployer.sol

@@ -98,10 +98,10 @@ contract AsyncDeployer is AsyncDeployerStorage, Initializable, AddressResolverUt
     /// @return newAsyncPromise The address of the deployed AsyncPromise proxy contract
     function deployAsyncPromiseContract(
         address invoker_,
-        uint40 requestCount_
+        bytes32 payloadId_
     ) external override onlyWatcher returns (address newAsyncPromise) {
         // creates init data and salt
-        (bytes32 salt, bytes memory initData) = _createAsyncPromiseParams(invoker_, requestCount_);
+        (bytes32 salt, bytes memory initData) = _createAsyncPromiseParams(invoker_, payloadId_);
         asyncPromiseCounter++;
 
         // deploys the proxy
@@ -131,18 +131,18 @@ contract AsyncDeployer is AsyncDeployerStorage, Initializable, AddressResolverUt
 
     function _createAsyncPromiseParams(
         address invoker_,
-        uint40 requestCount_
+        bytes32 payloadId_
     ) internal view returns (bytes32 salt, bytes memory initData) {
         bytes memory constructorArgs = abi.encode(
-            requestCount_,
+            payloadId_,
             invoker_,
             address(addressResolver__)
         );
 
         // creates init data
         initData = abi.encodeWithSelector(
             AsyncPromise.initialize.selector,
-            requestCount_,
+            payloadId_,
             invoker_,
             address(addressResolver__)
         );
@@ -183,9 +183,9 @@ contract AsyncDeployer is AsyncDeployerStorage, Initializable, AddressResolverUt
     /// @return The predicted address of the AsyncPromise proxy contract
     function getAsyncPromiseAddress(
         address invoker_,
-        uint40 requestCount_
+        bytes32 payloadId_
     ) public view override returns (address) {
-        (bytes32 salt, ) = _createAsyncPromiseParams(invoker_, requestCount_);
+        (bytes32 salt, ) = _createAsyncPromiseParams(invoker_, payloadId_);
         return _predictProxyAddress(salt, address(asyncPromiseBeacon));
     }