🪵 Introduce L2LogLocator for word-packing zkSync log indices

Author: KimlikDAO-bot

zksync/IZkSync.sol

@@ -2,32 +2,13 @@
 
 pragma solidity ^0.8.0;
 
+import {L2Log} from "./L2Log.sol";
+
 enum TxStatus {
     Failure,
     Success
 }
 
-/**
- * @dev The log passed from L2
- * @param l2ShardId The shard identifier, 0 - rollup, 1 - porter. All other values are not used but are reserved for
- * the future
- * @param isService A boolean flag that is part of the log along with `key`, `value`, and `sender` address.
- * This field is required formally but does not have any special meaning.
- * @param txNumberInBatch The L2 transaction number in the batch, in which the log was sent
- * @param sender The L2 address which sent the log
- * @param key The 32 bytes of information that was sent in the log
- * @param value The 32 bytes of information that was sent in the log
- * Both `key` and `value` are arbitrary 32-bytes selected by the log sender
- */
-struct L2Log {
-    uint8 l2ShardId;
-    bool isService;
-    uint16 txNumberInBatch;
-    address sender;
-    bytes32 key;
-    bytes32 value;
-}
-
 uint160 constant ALIAS_OFFSET = uint160(0x1111000000000000000000000000000000001111);
 
 /**

zksync/L2Log.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev The log passed from L2
+ * @param l2ShardId The shard identifier, 0 - rollup, 1 - porter. All other values are not used but are reserved for
+ * the future
+ * @param isService A boolean flag that is part of the log along with `key`, `value`, and `sender` address.
+ * This field is required formally but does not have any special meaning.
+ * @param txNumberInBatch The L2 transaction number in the batch, in which the log was sent
+ * @param sender The L2 address which sent the log
+ * @param key The 32 bytes of information that was sent in the log
+ * @param value The 32 bytes of information that was sent in the log
+ * Both `key` and `value` are arbitrary 32-bytes selected by the log sender
+ */
+struct L2Log {
+    uint8 l2ShardId;
+    bool isService;
+    uint16 txNumberInBatch;
+    address sender;
+    bytes32 key;
+    bytes32 value;
+}
+
+type L2LogLocator is uint256;
+
+function L2LogLocatorFrom(uint256 _batchNumber, uint256 _messageIndex, uint256 _txNumber) pure returns (L2LogLocator) {
+    return L2LogLocator.wrap(_batchNumber << 128 | _messageIndex << 16 | _txNumber);
+}
+
+function batchNumber(L2LogLocator self) pure returns (uint256) {
+    return L2LogLocator.unwrap(self) >> 128;
+}
+
+function messageIndex(L2LogLocator self) pure returns (uint256) {
+    return uint112(L2LogLocator.unwrap(self) >> 16);
+}
+
+function txNumber(L2LogLocator self) pure returns (uint256) {
+    return uint16(L2LogLocator.unwrap(self));
+}
+
+using {batchNumber, txNumber, messageIndex} for L2LogLocator global;

zksync/L2Log.t.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {L2LogLocator, L2LogLocatorFrom} from "./L2Log.sol";
+import {Test} from "forge-std/Test.sol";
+
+contract L2LogLocatorTest is Test {
+    function testAccessors() public pure {
+        L2LogLocator l = L2LogLocatorFrom(1, 2, 3);
+        assertEq(l.batchNumber(), 1);
+        assertEq(l.messageIndex(), 2);
+        assertEq(l.txNumber(), 3);
+
+        L2LogLocator k = L2LogLocatorFrom(type(uint128).max, type(uint112).max, type(uint16).max);
+        assertEq(k.batchNumber(), type(uint128).max);
+        assertEq(k.messageIndex(), type(uint112).max);
+        assertEq(k.txNumber(), type(uint16).max);
+
+        L2LogLocator m = L2LogLocatorFrom(type(uint128).max - 1, type(uint112).max - 1, type(uint16).max - 1);
+        assertEq(m.batchNumber(), type(uint128).max - 1);
+        assertEq(m.messageIndex(), type(uint112).max - 1);
+        assertEq(m.txNumber(), type(uint16).max - 1);
+    }
+}