Fix payload id

contracts/evmx/interfaces/IConfigurations.sol

@@ -26,7 +26,7 @@ interface IConfigurations {
     function getPlugConfigs(
         uint32 chainSlug_,
         bytes32 plug_
-    ) external view returns (bytes32, bytes32);
+    ) external view returns (bytes32, uint64);
 
     /// @notice Maps chain slug to their associated socket
     /// @param chainSlug_ The chain slug
@@ -36,10 +36,10 @@ interface IConfigurations {
     /// @notice Returns the socket for a given chain slug
     /// @param chainSlug_ The chain slug
     /// @return The socket
-    function switchboards(uint32 chainSlug_, bytes32 sbType_) external view returns (bytes32);
+    function switchboards(uint32 chainSlug_, bytes32 sbType_) external view returns (uint64);
 
     /// @notice Sets the switchboard for a network
-    function setSwitchboard(uint32 chainSlug_, bytes32 sbType_, bytes32 switchboard_) external;
+    function setSwitchboard(uint32 chainSlug_, bytes32 sbType_, uint64 switchboardId_) external;
 
     /// @notice Sets valid plugs for each chain slug
     /// @dev This function is used to verify if a plug deployed on a chain slug is valid connection to the app gateway

contracts/evmx/interfaces/IContractFactoryPlug.sol

@@ -15,7 +15,7 @@ interface IContractFactoryPlug {
         IsPlug isPlug_,
         bytes32 salt_,
         bytes32 appGatewayId_,
-        address switchboard_,
+        uint64 switchboardId_,
         bytes memory creationCode_,
         bytes memory initCallData_
     ) external returns (address);

contracts/evmx/plugs/ContractFactoryPlug.sol

@@ -35,15 +35,15 @@ contract ContractFactoryPlug is PlugBase, AccessControl, IContractFactoryPlug {
     /// @param isPlug_ Whether the contract to be deployed is a plug
     /// @param salt_ The salt used for create 2
     /// @param appGatewayId_ The app gateway id
-    /// @param switchboard_ The switchboard address
+    /// @param switchboardId_ The switchboard id
     /// @param creationCode_ The creation code
     /// @param initCallData_ The init call data
     /// @return addr The address of the deployed contract
     function deployContract(
         IsPlug isPlug_,
         bytes32 salt_,
         bytes32 appGatewayId_,
-        address switchboard_,
+        uint64 switchboardId_,
         bytes memory creationCode_,
         bytes memory initCallData_
     ) public override onlySocket returns (address addr) {
@@ -55,7 +55,8 @@ contract ContractFactoryPlug is PlugBase, AccessControl, IContractFactoryPlug {
             }
         }
 
-        if (isPlug_ == IsPlug.YES) IPlug(addr).initSocket(appGatewayId_, msg.sender, switchboard_);
+        if (isPlug_ == IsPlug.YES)
+            IPlug(addr).initSocket(appGatewayId_, msg.sender, switchboardId_);
 
         bytes memory returnData;
         if (initCallData_.length > 0) {
@@ -89,9 +90,9 @@ contract ContractFactoryPlug is PlugBase, AccessControl, IContractFactoryPlug {
     function connectSocket(
         bytes32 appGatewayId_,
         address socket_,
-        address switchboard_
+        uint64 switchboardId_
     ) external onlyOwner {
-        _connectSocket(appGatewayId_, socket_, switchboard_);
+        _connectSocket(appGatewayId_, socket_, switchboardId_);
     }
 
     /**

contracts/evmx/plugs/FeesPlug.sol

@@ -119,9 +119,9 @@ contract FeesPlug is IFeesPlug, PlugBase, AccessControl {
     function connectSocket(
         bytes32 appGatewayId_,
         address socket_,
-        address switchboard_
+        uint64 switchboardId_
     ) external onlyOwner {
-        _connectSocket(appGatewayId_, socket_, switchboard_);
+        _connectSocket(appGatewayId_, socket_, switchboardId_);
     }
 
     /**

contracts/evmx/watcher/Configurations.sol

@@ -21,8 +21,8 @@ abstract contract ConfigurationsStorage is IConfigurations {
 
     // slot 51
     /// @notice Maps chain slug to their associated switchboard
-    /// @dev chainSlug => sb type => switchboard address
-    mapping(uint32 => mapping(bytes32 => bytes32)) public switchboards;
+    /// @dev chainSlug => sb type => switchboard id
+    mapping(uint32 => mapping(bytes32 => uint64)) public switchboards;
 
     // slot 52
     /// @notice Maps chain slug to their associated socket
@@ -53,8 +53,8 @@ contract Configurations is ConfigurationsStorage, Initializable, Ownable, Watche
     /// @notice Emitted when a switchboard is set for a network
     /// @param chainSlug The identifier of the network
     /// @param sbType The type of switchboard
-    /// @param switchboard The address of the switchboard
-    event SwitchboardSet(uint32 chainSlug, bytes32 sbType, bytes32 switchboard);
+    /// @param switchboardId The id of the switchboard
+    event SwitchboardSet(uint32 chainSlug, bytes32 sbType, uint64 switchboardId);
 
     /// @notice Emitted when socket is set for a network
     /// @param chainSlug The identifier of the network
@@ -105,14 +105,14 @@ contract Configurations is ConfigurationsStorage, Initializable, Ownable, Watche
     /// @notice Sets the switchboard for a network
     /// @param chainSlug_ The identifier of the network
     /// @param sbType_ The type of switchboard, hash of a string
-    /// @param switchboard_ The address of the switchboard
+    /// @param switchboardId_ The id of the switchboard
     function setSwitchboard(
         uint32 chainSlug_,
         bytes32 sbType_,
-        bytes32 switchboard_
+        uint64 switchboardId_
     ) external onlyOwner {
-        switchboards[chainSlug_][sbType_] = switchboard_;
-        emit SwitchboardSet(chainSlug_, sbType_, switchboard_);
+        switchboards[chainSlug_][sbType_] = switchboardId_;
+        emit SwitchboardSet(chainSlug_, sbType_, switchboardId_);
     }
 
     /// @notice Sets the valid plugs for an app gateway
@@ -135,15 +135,15 @@ contract Configurations is ConfigurationsStorage, Initializable, Ownable, Watche
     /// @dev Returns zero addresses if configuration doesn't exist
     /// @param chainSlug_ The identifier of the network
     /// @param plug_ The address of the plug
-    /// @return The app gateway id and switchboard address for the plug
+    /// @return The app gateway id and switchboard id for the plug
     /// @dev Returns zero addresses if configuration doesn't exist
     function getPlugConfigs(
         uint32 chainSlug_,
         bytes32 plug_
-    ) public view returns (bytes32, bytes32) {
+    ) public view returns (bytes32, uint64) {
         return (
             _plugConfigs[chainSlug_][plug_].appGatewayId,
-            _plugConfigs[chainSlug_][plug_].switchboard
+            _plugConfigs[chainSlug_][plug_].switchboardId
         );
     }
 
@@ -159,9 +159,10 @@ contract Configurations is ConfigurationsStorage, Initializable, Ownable, Watche
         address appGateway_,
         bytes32 switchboardType_
     ) external view {
-        (bytes32 appGatewayId, bytes32 switchboard) = getPlugConfigs(chainSlug_, target_);
+        (bytes32 appGatewayId, uint64 switchboardId) = getPlugConfigs(chainSlug_, target_);
         if (appGatewayId != toBytes32Format(appGateway_)) revert InvalidGateway();
-        if (switchboard != switchboards[chainSlug_][switchboardType_]) revert InvalidSwitchboard();
+        if (switchboardId != switchboards[chainSlug_][switchboardType_])
+            revert InvalidSwitchboard();
     }
 
     /**

contracts/evmx/watcher/PromiseResolver.sol

@@ -54,7 +54,7 @@ contract PromiseResolver is IPromiseResolver, WatcherBase {
         if (payloadParams.deadline < block.timestamp) revert DeadlinePassed();
 
         address asyncPromise = payloadParams.asyncPromise;
-        requestCount = payloadParams.requestCount;
+        requestCount = uint40(payloadParams.payloadPointer >> 120);
 
         if (asyncPromise != address(0)) {
             success = IPromise(asyncPromise).markResolved(resolvedPromise_);
@@ -85,7 +85,7 @@ contract PromiseResolver is IPromiseResolver, WatcherBase {
         if (payloadParams.deadline > block.timestamp) revert DeadlineNotPassedForOnChainRevert();
 
         // marks the request as cancelled and settles the fees
-        requestHandler__().cancelRequestForReverts(payloadParams.requestCount);
+        requestHandler__().cancelRequestForReverts(uint40(payloadParams.payloadPointer >> 120));
 
         // marks the promise as onchain reverting if the request is reverting onchain
         if (isRevertingOnchain_ && payloadParams.asyncPromise != address(0))

contracts/evmx/watcher/RequestHandler.sol

@@ -227,9 +227,7 @@ contract RequestHandler is RequestHandlerStorage, Initializable, Ownable, Addres
                 _requestBatchIds[requestCount_].push(nextBatchCount);
             }
 
-            // get the switchboard address from the configurations
-            // returns bytes32(0) for schedule precompile and reads if sb type not set
-            bytes32 switchboard = watcher__().configurations__().switchboards(
+            uint64 switchboardId = watcher__().configurations__().switchboards(
                 queuePayloadParam.transaction.chainSlug,
                 queuePayloadParam.switchboardType
             );
@@ -243,22 +241,20 @@ contract RequestHandler is RequestHandlerStorage, Initializable, Ownable, Addres
             result.totalEstimatedWatcherFees += estimatedFees;
 
             // create payload id
-            uint40 payloadCount = payloadCounter++;
+            uint160 payloadPointer = (uint160(requestCount_) << 120) |
+                (uint160(nextBatchCount) << 80) |
+                uint160(payloadCounter++);
+
             bytes32 payloadId = createPayloadId(
-                requestCount_,
-                nextBatchCount,
-                payloadCount,
-                switchboard,
-                // todo: add evmx chain slug if schedule or read?
+                payloadPointer,
+                switchboardId,
                 queuePayloadParam.transaction.chainSlug
             );
             _batchPayloadIds[nextBatchCount].push(payloadId);
 
             // create prev digest hash
             PayloadParams memory p;
-            p.requestCount = requestCount_;
-            p.batchCount = nextBatchCount;
-            p.payloadCount = payloadCount;
+            p.payloadPointer = payloadPointer;
             p.callType = callType;
             p.asyncPromise = queueParams_[i].asyncPromise;
             p.appGateway = appGateway_;

contracts/evmx/watcher/precompiles/WritePrecompile.sol

@@ -160,8 +160,7 @@ contract WritePrecompile is WritePrecompileStorage, Initializable, Ownable, Watc
             uint256 gasLimit,
             uint256 value,
 
-        ) =
-            abi.decode(
+        ) = abi.decode(
                 payloadParams.precompileData,
                 (address, Transaction, WriteFinality, uint256, uint256, bytes32)
             );
@@ -171,8 +170,8 @@ contract WritePrecompile is WritePrecompileStorage, Initializable, Ownable, Watc
         fees = getPrecompileFees(payloadParams.precompileData);
 
         bytes32 prevBatchDigestHash = getPrevBatchDigestHash(
-            payloadParams.requestCount,
-            payloadParams.batchCount
+            uint40(payloadParams.payloadPointer >> 120),
+            uint40(payloadParams.payloadPointer >> 80)
         );
 
         // create digest

contracts/protocol/Socket.sol

@@ -76,16 +76,13 @@ contract Socket is SocketUtils {
             revert InsufficientMsgValue();
 
         bytes32 payloadId = createPayloadId(
-            executeParams_.requestCount,
-            executeParams_.batchCount,
-            executeParams_.payloadCount,
-            toBytes32Format(plugConfig.switchboard),
+            executeParams_.payloadPointer,
+            plugConfig.switchboardId,
             chainSlug
         );
 
         // validate the execution status
         _validateExecutionStatus(payloadId);
-
         address transmitter = transmissionParams_.transmitterSignature.length > 0
             ? _recoverSigner(
                 keccak256(abi.encode(address(this), payloadId)),
@@ -104,20 +101,20 @@ contract Socket is SocketUtils {
         payloadIdToDigest[payloadId] = digest;
 
         // verify the digest
-        _verify(digest, payloadId, plugConfig.switchboard);
+        _verify(digest, payloadId, plugConfig.switchboardId);
 
         return _execute(payloadId, executeParams_, transmissionParams_);
     }
 
     ////////////////////////////////////////////////////////
     ////////////////// INTERNAL FUNCS //////////////////////
     ////////////////////////////////////////////////////////
-    function _verify(bytes32 digest_, bytes32 payloadId_, address switchboard_) internal view {
-        if (isValidSwitchboard[switchboard_] != SwitchboardStatus.REGISTERED)
+    function _verify(bytes32 digest_, bytes32 payloadId_, uint64 switchboardId_) internal view {
+        if (isValidSwitchboard[switchboardId_] != SwitchboardStatus.REGISTERED)
             revert InvalidSwitchboard();
 
         // NOTE: is the the first un-trusted call in the system, another one is Plug.call
-        if (!ISwitchboard(switchboard_).allowPayload(digest_, payloadId_))
+        if (!ISwitchboard(switchboardAddresses[switchboardId_]).allowPayload(digest_, payloadId_))
             revert VerificationFailed();
     }
 
@@ -185,24 +182,21 @@ contract Socket is SocketUtils {
 
         // if no sibling plug is found for the given chain slug, revert
         if (plugConfig.appGatewayId == bytes32(0)) revert PlugNotFound();
-        if (isValidSwitchboard[plugConfig.switchboard] != SwitchboardStatus.REGISTERED)
+        if (isValidSwitchboard[plugConfig.switchboardId] != SwitchboardStatus.REGISTERED)
             revert InvalidSwitchboard();
 
         bytes memory plugOverrides = IPlug(msg.sender).overrides();
         triggerId = _encodeTriggerId();
 
         // todo: need gas limit?
-        ISwitchboard(plugConfig.switchboard).processTrigger{value: msg.value}(
-            msg.sender,
-            triggerId,
-            msg.data,
-            plugOverrides
-        );
+        ISwitchboard(switchboardAddresses[plugConfig.switchboardId]).processTrigger{
+            value: msg.value
+        }(msg.sender, triggerId, msg.data, plugOverrides);
 
         emit AppGatewayCallRequested(
             triggerId,
             plugConfig.appGatewayId,
-            toBytes32Format(plugConfig.switchboard),
+            plugConfig.switchboardId,
             toBytes32Format(plug_),
             plugOverrides,
             msg.data

contracts/protocol/SocketBatcher.sol

@@ -64,13 +64,12 @@ contract SocketBatcher is ISocketBatcher, Ownable {
     function attestCCTPAndProveAndExecute(
         CCTPExecutionParams calldata execParams_,
         CCTPBatchParams calldata cctpParams_,
+        uint64 switchboardId_,
         address switchboard_
     ) external payable returns (bool, bytes memory) {
         bytes32 payloadId = createPayloadId(
-            execParams_.executeParams.requestCount,
-            execParams_.executeParams.batchCount,
-            execParams_.executeParams.payloadCount,
-            bytes32(uint256(uint160(address(switchboard_)))),
+            execParams_.executeParams.payloadPointer,
+            switchboardId_,
             socket__.chainSlug()
         );
         ICCTPSwitchboard(switchboard_).attestVerifyAndProveExecutions(