DigestMessages implementation

src/Nethermind.Arbitrum.Test/Infrastructure/ArbitrumRpcTestBlockchain.cs

@@ -316,6 +316,11 @@ public Task<ResultWrapper<MessageResult>> DigestMessage(DigestMessageParameters
             return rpc.DigestMessage(parameters);
         }
 
+        public Task<ResultWrapper<BulkMessageResult>> DigestMessages(DigestMessageBulkParameters parameters)
+        {
+            return rpc.DigestMessages(parameters);
+        }
+
         public Task<ResultWrapper<MessageResult>> ResultAtMessageIndex(ulong messageIndex)
         {
             return rpc.ResultAtMessageIndex(messageIndex);

src/Nethermind.Arbitrum/Data/DigestMessageParameters.cs

@@ -37,3 +37,10 @@ public record DigestInitMessage(
     [property: JsonPropertyName("initialL1BaseFee")] UInt256 InitialL1BaseFee,
     [property: JsonPropertyName("serializedChainConfig"), JsonConverter(typeof(Base64Converter))] byte[]? SerializedChainConfig
 );
+
+
+public record DigestMessageBulkParameters(
+    [property: JsonPropertyName("startIndex")] ulong StartIndex,
+    [property: JsonPropertyName("messages")] MessageWithMetadata[] Messages,
+    [property: JsonPropertyName("messagesForPrefetch")] MessageWithMetadata[]? MessageForPrefetch
+);

src/Nethermind.Arbitrum/Data/MessageResult.cs

@@ -12,4 +12,25 @@ public struct MessageResult : IEquatable<MessageResult>
 
         public bool Equals(MessageResult other) => BlockHash.Equals(other.BlockHash) && SendRoot.Equals(other.SendRoot);
     }
+
+    public struct BulkMessageResult : IEquatable<BulkMessageResult>
+    {
+        public MessageResult[] Results;
+
+        public bool Equals(BulkMessageResult other)
+        {
+            if (Results.Length != other.Results.Length)
+            {
+                return false;
+            }
+            for (int i = 0; i < Results.Length; i++)
+            {
+                if (!Results[i].Equals(other.Results[i]))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
 }

src/Nethermind.Arbitrum/Modules/ArbitrumRpcModule.cs

@@ -97,6 +97,47 @@ public virtual async Task<ResultWrapper<MessageResult>> DigestMessage(DigestMess
         }
     }
 
+    public virtual async Task<ResultWrapper<BulkMessageResult>> DigestMessages(DigestMessageBulkParameters parameters)
+    {
+        // Non-blocking attempt to acquire the semaphore.
+        if (!await CreateBlocksSemaphore.WaitAsync(0))
+            return ResultWrapper<BulkMessageResult>.Fail("CreateBlock mutex held.", ErrorCodes.InternalError);
+
+        try
+        {
+            BulkMessageResult bulkMessageResult = new()
+            {
+                Results = new MessageResult[parameters.Messages.Length]
+            };
+
+            for (ulong blockIndex = parameters.StartIndex; blockIndex < parameters.StartIndex + (ulong)parameters.Messages.Length; blockIndex++)
+            {
+                ulong relativeIndex = blockIndex - parameters.StartIndex;
+                MessageWithMetadata message = parameters.Messages[relativeIndex];
+
+                long blockNumber = (await MessageIndexToBlockNumber(blockIndex)).Data;
+                BlockHeader? headBlockHeader = blockTree.Head?.Header;
+
+                if (headBlockHeader is not null && headBlockHeader.Number + 1 != blockNumber)
+                    return ResultWrapper<BulkMessageResult>.Fail(
+                        $"Wrong block number in digest got {blockNumber} expected {headBlockHeader.Number}");
+
+                ResultWrapper<MessageResult> singleResult = blocksConfig.BuildBlocksOnMainState
+                    ? await ProduceBlockWithoutWaitingOnProcessingQueueAsync(message, blockNumber, headBlockHeader)
+                    : await ProduceBlockWhileLockedAsync(message, blockNumber, headBlockHeader);
+
+                if (singleResult.Result == Result.Success)
+                    bulkMessageResult.Results[relativeIndex] = singleResult.Data;
+            }
+            return ResultWrapper<BulkMessageResult>.Success(bulkMessageResult);
+        }
+        finally
+        {
+            // Ensure the semaphore is released, equivalent to Go's `defer Unlock()`.
+            CreateBlocksSemaphore.Release();
+        }
+    }
+
     public async Task<ResultWrapper<MessageResult>> ResultAtMessageIndex(ulong messageIndex)
     {
         try

src/Nethermind.Arbitrum/Modules/IArbitrumRpcModule.cs

@@ -16,6 +16,9 @@ public interface IArbitrumRpcModule : IRpcModule
         [JsonRpcMethod(IsSharable = false, IsImplemented = true)]
         Task<ResultWrapper<MessageResult>> DigestMessage(DigestMessageParameters parameters);
 
+        [JsonRpcMethod(IsSharable = false, IsImplemented = true)]
+        Task<ResultWrapper<BulkMessageResult>> DigestMessages(DigestMessageBulkParameters parameters);
+
         Task<ResultWrapper<MessageResult>> ResultAtMessageIndex(UInt64 messageIndex);
 
         Task<ResultWrapper<ulong>> HeadMessageIndex();