diff --git a/Libplanet.Net/Consensus/ConsensusContext.cs b/Libplanet.Net/Consensus/ConsensusContext.cs
index e9bc272560f..2f061829b9b 100644
--- a/Libplanet.Net/Consensus/ConsensusContext.cs
+++ b/Libplanet.Net/Consensus/ConsensusContext.cs
@@ -130,6 +130,11 @@ public ConsensusStep Step
             }
         }
 
+        /// <summary>
+        /// Represents if <see cref="ConsensusContext"/> is bootstrapping or not.
+        /// </summary>
+        internal bool Bootstrapping => _bootstrapping;
+
         /// <summary>
         /// A dictionary of <see cref="Context"/> for each heights. Each key represents the
         /// height of value, and value is the <see cref="Context"/>.
@@ -304,6 +309,78 @@ public IEnumerable<ConsensusMsg> HandleVoteSetBits(VoteSetBits voteSetBits)
             return Array.Empty<ConsensusMsg>();
         }
 
+        /// <summary>
+        /// Handles a received <see cref="ConsensusBootstrapMsg"/>
+        /// and return <see cref="VotesRecall"/> to send as a reply.
+        /// </summary>
+        /// <param name="bootstrapMsg">The <see cref="ConsensusBootstrapMsg"/>
+        /// received from bootstrapping validator.
+        /// </param>
+        /// <returns>
+        /// A nullable <see cref="VotesRecall"/> to reply back.
+        /// </returns>
+        public VotesRecall? HandleBootstrap(ConsensusBootstrapMsg bootstrapMsg)
+        {
+            long height = bootstrapMsg.Bootstrap.Height;
+            int round = bootstrapMsg.Bootstrap.Round;
+            if (height < Height)
+            {
+                _logger.Debug(
+                    "Ignore a received Bootstrap as its height " +
+                    "#{Height} is lower than the current context's height #{ContextHeight}",
+                    height,
+                    Height);
+            }
+            else
+            {
+                lock (_contextLock)
+                {
+                    if (_contexts.ContainsKey(height))
+                    {
+                        return _contexts[height]
+                            .GetVotesRecall(round);
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Handles a received <see cref="ConsensusVotesRecallMsg"/>.
+        /// </summary>
+        /// <param name="votesRecallMsg">The <see cref="ConsensusVotesRecallMsg"/>
+        /// received from running validator.
+        /// </param>
+        /// <returns>
+        /// <see langword="true"/> if <paramref name="votesRecallMsg"/> is dispatched to
+        /// a <see cref="Context"/>, <see langword="false"/> otherwise.
+        /// </returns>
+        public bool HandleVotesRecall(ConsensusVotesRecallMsg votesRecallMsg)
+        {
+            long height = votesRecallMsg.Height;
+            if (height < Height)
+            {
+                _logger.Debug(
+                    "Discarding a received message as its height #{MessageHeight} " +
+                    "is lower than the current context's height #{ContextHeight}",
+                    height,
+                    Height);
+                return false;
+            }
+
+            lock (_contextLock)
+            {
+                if (!_contexts.ContainsKey(height))
+                {
+                    _contexts[height] = CreateContext(height);
+                }
+
+                _contexts[height].ProduceMessage(votesRecallMsg);
+                return true;
+            }
+        }
+
         /// <summary>
         /// Returns the summary for <see cref="ConsensusContext"/>.
         /// </summary>
diff --git a/Libplanet.Net/Consensus/ConsensusReactor.cs b/Libplanet.Net/Consensus/ConsensusReactor.cs
index 157f1beb3fa..040f78f9b93 100644
--- a/Libplanet.Net/Consensus/ConsensusReactor.cs
+++ b/Libplanet.Net/Consensus/ConsensusReactor.cs
@@ -190,7 +190,7 @@ private void ProcessMessage(MessageContent content)
                             VoteSetBits voteSetBits = _consensusContext.Contexts[maj23Msg.Height]
                                 .GetVoteSetBits(
                                     maj23Msg.Round,
-                                    maj23Msg.BlockHash,
+                                    maj23Msg.Maj23.BlockHash,
                                     maj23Msg.Maj23.Flag);
                             var sender = _gossip.Peers.First(
                                 peer => peer.PublicKey.Equals(maj23Msg.ValidatorPublicKey));
@@ -210,6 +210,38 @@ private void ProcessMessage(MessageContent content)
 
                     break;
 
+                case ConsensusBootstrapMsg bootstrapMsg:
+                    try
+                    {
+                        _consensusContext.HandleMessage(bootstrapMsg);
+                        var sender = _gossip.Peers.First(
+                        peer => peer.PublicKey.Equals(bootstrapMsg.ValidatorPublicKey));
+                        var reply = _consensusContext.HandleBootstrap(bootstrapMsg);
+                        if (reply is null)
+                        {
+                            // Reply is not needed. Ignore the message.
+                            break;
+                        }
+
+                        _gossip.PublishMessage(
+                            new ConsensusVotesRecallMsg(reply),
+                            new[] { sender });
+                    }
+                    catch (InvalidOperationException)
+                    {
+                        _logger.Debug(
+                            "Cannot respond received ConsensusBootstrapMsg message " +
+                            "{Message} since there is no corresponding peer in the table",
+                            bootstrapMsg);
+                    }
+
+                    break;
+
+                case ConsensusVotesRecallMsg votesRecallMsg:
+                    // Note: ConsensusVoteSetBitsMsg will not be stored to context's message log.
+                    _consensusContext.HandleVotesRecall(votesRecallMsg);
+                    break;
+
                 case ConsensusMsg consensusMsg:
                     _consensusContext.HandleMessage(consensusMsg);
                     break;
diff --git a/Libplanet.Net/Consensus/Context.Async.cs b/Libplanet.Net/Consensus/Context.Async.cs
index 0198fa90503..d3d8035ee2a 100644
--- a/Libplanet.Net/Consensus/Context.Async.cs
+++ b/Libplanet.Net/Consensus/Context.Async.cs
@@ -23,16 +23,12 @@ public void Start(BlockCommit? lastCommit = null, bool bootstrapping = false)
                 Height,
                 lastCommit);
             _lastCommit = lastCommit;
+            _bootstrapping = bootstrapping;
             ProduceMutation(() => StartRound(0));
 
             // FIXME: Exceptions inside tasks should be handled properly.
             _ = MessageConsumerTask(_cancellationTokenSource.Token);
             _ = MutationConsumerTask(_cancellationTokenSource.Token);
-
-            if (bootstrapping)
-            {
-                _ = BootstrappingTask(_cancellationTokenSource.Token);
-            }
         }
 
         /// <summary>
@@ -99,30 +95,6 @@ internal async Task MutationConsumerTask(CancellationToken cancellationToken)
             }
         }
 
-        internal async Task BootstrappingTask(CancellationToken cancellationToken)
-        {
-            while (true)
-            {
-                try
-                {
-                    cancellationToken.ThrowIfCancellationRequested();
-                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
-                }
-                catch (OperationCanceledException oce)
-                {
-                    _logger.Debug(oce, "Cancellation was requested");
-                    ExceptionOccurred?.Invoke(this, oce);
-                    throw;
-                }
-#pragma warning disable S125
-                /*if (_heightVoteSet.GetRandomMessage() is { } message)
-                {
-                    BroadcastMessage(message)
-                }*/
-#pragma warning restore S125
-            }
-        }
-
         /// <summary>
         /// Adds <paramref name="message"/> to the message queue.
         /// </summary>
diff --git a/Libplanet.Net/Consensus/Context.Mutate.cs b/Libplanet.Net/Consensus/Context.Mutate.cs
index 880507dd1a9..d3f0d06a7f2 100644
--- a/Libplanet.Net/Consensus/Context.Mutate.cs
+++ b/Libplanet.Net/Consensus/Context.Mutate.cs
@@ -25,6 +25,14 @@ private void StartRound(int round)
                 ToString());
             Round = round;
             _heightVoteSet.SetRound(round);
+            if (_bootstrapping)
+            {
+                Bootstrap bootstrap = new BootstrapMetadata(
+                    Height, round, DateTimeOffset.UtcNow, _privateKey.PublicKey).Sign(_privateKey);
+                BroadcastMessage(
+                    new ConsensusBootstrapMsg(bootstrap));
+            }
+
             Proposal = null;
             Step = ConsensusStep.Propose;
             if (_validatorSet.GetProposer(Height, Round).PublicKey == _privateKey.PublicKey)
@@ -101,33 +109,55 @@ private bool AddMessage(ConsensusMsg message)
                         message);
                 }
 
-                switch (message)
+                if (message is ConsensusVoteMsg voteMsg)
                 {
-                    case ConsensusProposalMsg proposal:
-                        AddProposal(proposal.Proposal);
-                        break;
-                    case ConsensusPreVoteMsg preVote:
-                        _heightVoteSet.AddVote(preVote.PreVote);
-                        break;
-                    case ConsensusPreCommitMsg preCommit:
-                        _heightVoteSet.AddVote(preCommit.PreCommit);
-                        break;
-                    case ConsensusMaj23Msg maj23:
-                        _heightVoteSet.SetPeerMaj23(maj23.Maj23);
-                        break;
+                    switch (voteMsg)
+                    {
+                        case ConsensusProposalMsg proposal:
+                            AddProposal(proposal.Proposal);
+                            break;
+                        case ConsensusPreVoteMsg preVote:
+                            _heightVoteSet.AddVote(preVote.PreVote);
+                            break;
+                        case ConsensusPreCommitMsg preCommit:
+                            _heightVoteSet.AddVote(preCommit.PreCommit);
+                            break;
+                    }
+
+                    _logger.Debug(
+                        "{FName}: Message: {Message} => Height: {Height}, Round: {Round}, " +
+                        "Validator Address: {VAddress}, " +
+                        "Hash: {BlockHash}. (context: {Context})",
+                        nameof(AddMessage),
+                        voteMsg,
+                        voteMsg.Height,
+                        voteMsg.Round,
+                        voteMsg.ValidatorPublicKey.ToAddress(),
+                        voteMsg.BlockHash,
+                        ToString());
                 }
+                else
+                {
+                    switch (message)
+                    {
+                        case ConsensusMaj23Msg maj23:
+                            _heightVoteSet.SetPeerMaj23(maj23.Maj23);
+                            break;
+                        case ConsensusVotesRecallMsg votesRecall:
+                            CatchupWithVotesRecall(votesRecall.VotesRecall);
+                            break;
+                    }
 
-                _logger.Debug(
-                    "{FName}: Message: {Message} => Height: {Height}, Round: {Round}, " +
-                    "Validator Address: {VAddress}, " +
-                    "Hash: {BlockHash}. (context: {Context})",
-                    nameof(AddMessage),
-                    message,
-                    message.Height,
-                    message.Round,
-                    message.ValidatorPublicKey.ToAddress(),
-                    message.BlockHash,
-                    ToString());
+                    _logger.Debug(
+                        "{FName}: Message: {Message} => Height: {Height}, Round: {Round}, " +
+                        "Validator Address: {VAddress}. (context: {Context})",
+                        nameof(AddMessage),
+                        message,
+                        message.Height,
+                        message.Round,
+                        message.ValidatorPublicKey.ToAddress(),
+                        ToString());
+                }
 
                 return true;
             }
diff --git a/Libplanet.Net/Consensus/Context.cs b/Libplanet.Net/Consensus/Context.cs
index aeabe6568c4..dfb90dd6554 100644
--- a/Libplanet.Net/Consensus/Context.cs
+++ b/Libplanet.Net/Consensus/Context.cs
@@ -105,6 +105,7 @@ private readonly
         private Block? _decision;
         private int _committedRound;
         private BlockCommit? _lastCommit;
+        private bool _bootstrapping;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Context"/> class.
@@ -178,6 +179,7 @@ private Context(
             _validRound = -1;
             _decision = null;
             _committedRound = -1;
+            _bootstrapping = false;
             _blockChain = blockChain;
             _codec = new Codec();
             _messageRequests = Channel.CreateUnbounded<ConsensusMsg>();
@@ -299,6 +301,48 @@ public IEnumerable<ConsensusMsg> GetVoteSetBitsResponse(VoteSetBits voteSetBits)
             });
         }
 
+        public VotesRecall GetVotesRecall(int round)
+        {
+            ImmutableHashSet<Vote> votes;
+            if (round < Round)
+            {
+                round++;
+            }
+
+            votes = _heightVoteSet.PreVotes(round).List().Concat(
+                _heightVoteSet.PreCommits(round).List()).ToImmutableHashSet();
+
+            return new VotesRecallMetadata(
+                Height,
+                round,
+                DateTimeOffset.UtcNow,
+                _privateKey.PublicKey,
+                votes).Sign(_privateKey);
+        }
+
+        public void CatchupWithVotesRecall(VotesRecall votesRecall)
+        {
+            foreach (Vote vote in votesRecall.Votes)
+            {
+                if (vote.Height != Height)
+                {
+                    continue;
+                }
+
+                if (vote.Round > Round + 1)
+                {
+                    continue;
+                }
+
+                if (!vote.Verify())
+                {
+                    continue;
+                }
+
+                _heightVoteSet.AddVote(vote);
+            }
+        }
+
         /// <summary>
         /// Returns the summary of context in JSON-formatted string.
         /// </summary>
diff --git a/Libplanet.Net/Consensus/HeightVoteSet.cs b/Libplanet.Net/Consensus/HeightVoteSet.cs
index b13aa7a5c38..d02f73f0580 100644
--- a/Libplanet.Net/Consensus/HeightVoteSet.cs
+++ b/Libplanet.Net/Consensus/HeightVoteSet.cs
@@ -74,7 +74,6 @@ public void SetRound(int round)
         {
             lock (_lock)
             {
-                // FIXME: This shouldn't be _round + 1?
                 var newRound = _round + 1;
                 if (_round != 0 && (round < newRound))
                 {
diff --git a/Libplanet.Net/Messages/ConsensusBootstrapMsg.cs b/Libplanet.Net/Messages/ConsensusBootstrapMsg.cs
new file mode 100644
index 00000000000..767e5693a5a
--- /dev/null
+++ b/Libplanet.Net/Messages/ConsensusBootstrapMsg.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using Libplanet.Consensus;
+
+namespace Libplanet.Net.Messages
+{
+    /// <summary>
+    /// A message class for informing that peer is on bootstrapping.
+    /// </summary>
+    public class ConsensusBootstrapMsg : ConsensusMsg
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsensusBootstrapMsg"/> class.
+        /// </summary>
+        /// <param name="bootstrap">A <see cref="Bootstrap"/> information
+        /// of <see cref="Validator"/>.</param>
+        public ConsensusBootstrapMsg(Bootstrap bootstrap)
+            : base(bootstrap.ValidatorPublicKey, bootstrap.Height, bootstrap.Round)
+        {
+            Bootstrap = bootstrap;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsensusBootstrapMsg"/> class
+        /// with marshalled message.
+        /// </summary>
+        /// <param name="dataframes">A marshalled message.</param>
+        public ConsensusBootstrapMsg(byte[][] dataframes)
+            : this(bootstrap: new Bootstrap(dataframes[0]))
+        {
+        }
+
+        /// <summary>
+        /// A <see cref="Bootstrap"/> of the message.
+        /// </summary>
+        public Bootstrap Bootstrap { get; }
+
+        /// <inheritdoc cref="MessageContent.DataFrames"/>
+        public override IEnumerable<byte[]> DataFrames =>
+            new List<byte[]> { Bootstrap.ToByteArray() };
+
+        /// <inheritdoc cref="MessageContent.MessageType"/>
+        public override MessageType Type => MessageType.BootstrapMsg;
+
+        /// <inheritdoc cref="ConsensusMsg.Equals(ConsensusMsg?)"/>
+        public override bool Equals(ConsensusMsg? other)
+        {
+            return other is ConsensusBootstrapMsg message &&
+                message.Bootstrap.Equals(Bootstrap);
+        }
+
+        /// <inheritdoc cref="ConsensusMsg.Equals(object?)"/>
+        public override bool Equals(object? obj)
+        {
+            return obj is ConsensusMsg other && Equals(other);
+        }
+
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Type, Bootstrap);
+        }
+    }
+}
diff --git a/Libplanet.Net/Messages/ConsensusMaj23Msg.cs b/Libplanet.Net/Messages/ConsensusMaj23Msg.cs
index 40551d1709f..f1d34e932b3 100644
--- a/Libplanet.Net/Messages/ConsensusMaj23Msg.cs
+++ b/Libplanet.Net/Messages/ConsensusMaj23Msg.cs
@@ -14,7 +14,7 @@ public class ConsensusMaj23Msg : ConsensusMsg
         /// </summary>
         /// <param name="maj23">A <see cref="Maj23"/> of given height and round.</param>
         public ConsensusMaj23Msg(Maj23 maj23)
-            : base(maj23.ValidatorPublicKey, maj23.Height, maj23.Round, maj23.BlockHash)
+            : base(maj23.ValidatorPublicKey, maj23.Height, maj23.Round)
         {
             Maj23 = maj23;
         }
@@ -41,17 +41,20 @@ public ConsensusMaj23Msg(byte[][] dataframes)
         /// <inheritdoc cref="MessageContent.MessageType"/>
         public override MessageType Type => MessageType.ConsensusMaj23Msg;
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(ConsensusMsg?)"/>
         public override bool Equals(ConsensusMsg? other)
         {
             return other is ConsensusMaj23Msg message &&
                    message.Maj23.Equals(Maj23);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(object?)"/>
         public override bool Equals(object? obj)
         {
             return obj is ConsensusMaj23Msg other && Equals(other);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
         public override int GetHashCode()
         {
             return HashCode.Combine(Type, Maj23);
diff --git a/Libplanet.Net/Messages/ConsensusMsg.cs b/Libplanet.Net/Messages/ConsensusMsg.cs
index 3f152502f6d..808404679f3 100644
--- a/Libplanet.Net/Messages/ConsensusMsg.cs
+++ b/Libplanet.Net/Messages/ConsensusMsg.cs
@@ -1,5 +1,4 @@
 using System;
-using Libplanet.Blocks;
 using Libplanet.Crypto;
 using Libplanet.Net.Consensus;
 
@@ -17,17 +16,14 @@ public abstract class ConsensusMsg : MessageContent, IEquatable<ConsensusMsg>
         /// A <see cref="PublicKey"/> of the validator who made this message.</param>
         /// <param name="height">A <see cref="Context.Height"/> the message is for.</param>
         /// <param name="round">A <see cref="Context.Round"/> the message is written for.</param>
-        /// <param name="blockHash">A <see cref="BlockHash"/> the message is written for.</param>
         protected ConsensusMsg(
             PublicKey validatorPublicKey,
             long height,
-            int round,
-            BlockHash blockHash)
+            int round)
         {
             ValidatorPublicKey = validatorPublicKey;
             Round = round;
             Height = height;
-            BlockHash = blockHash;
         }
 
         /// <summary>
@@ -46,14 +42,21 @@ protected ConsensusMsg(
         public int Round { get; }
 
         /// <summary>
-        /// A <see cref="BlockHash"/> the message is written for.
+        /// Indicates whether the current <see cref="ConsensusMsg"/>
+        /// is equal to another <see cref="ConsensusMsg"/>.
         /// </summary>
-        public BlockHash BlockHash { get; }
-
+        /// <param name="other">An <see cref="ConsensusMsg"/> to compare with this
+        /// <see cref="ConsensusMsg"/>.</param>
+        /// <returns>
+        /// true if the current <see cref="ConsensusMsg"/> is equal to the other parameter;
+        /// otherwise, false.
+        /// </returns>
         public abstract bool Equals(ConsensusMsg? other);
 
+        /// <inheritdoc cref="IEquatable{T}.Equals(T)"/>
         public abstract override bool Equals(object? obj);
 
+        /// <inheritdoc cref="object.GetHashCode"/>
         public abstract override int GetHashCode();
     }
 }
diff --git a/Libplanet.Net/Messages/ConsensusPreCommitMsg.cs b/Libplanet.Net/Messages/ConsensusPreCommitMsg.cs
index 117cb12c326..10b31787871 100644
--- a/Libplanet.Net/Messages/ConsensusPreCommitMsg.cs
+++ b/Libplanet.Net/Messages/ConsensusPreCommitMsg.cs
@@ -8,7 +8,7 @@ namespace Libplanet.Net.Messages
     /// <summary>
     /// A message class for <see cref="ConsensusStep.PreCommit"/>.
     /// </summary>
-    public class ConsensusPreCommitMsg : ConsensusMsg
+    public class ConsensusPreCommitMsg : ConsensusVoteMsg
     {
         private static Bencodex.Codec _codec = new Bencodex.Codec();
 
@@ -55,17 +55,20 @@ public ConsensusPreCommitMsg(byte[][] dataframes)
         /// <inheritdoc cref="MessageContent.MessageType"/>
         public override MessageType Type => MessageType.ConsensusCommit;
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(ConsensusMsg?)"/>
         public override bool Equals(ConsensusMsg? other)
         {
             return other is ConsensusPreCommitMsg message &&
                 PreCommit.Equals(message.PreCommit);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(object?)"/>
         public override bool Equals(object? obj)
         {
             return obj is ConsensusMsg other && Equals(other);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
         public override int GetHashCode()
         {
             return HashCode.Combine(Type, PreCommit);
diff --git a/Libplanet.Net/Messages/ConsensusPreVoteMsg.cs b/Libplanet.Net/Messages/ConsensusPreVoteMsg.cs
index 107b896beff..1bae7271bb9 100644
--- a/Libplanet.Net/Messages/ConsensusPreVoteMsg.cs
+++ b/Libplanet.Net/Messages/ConsensusPreVoteMsg.cs
@@ -8,7 +8,7 @@ namespace Libplanet.Net.Messages
     /// <summary>
     /// A message class for <see cref="ConsensusStep.PreVote"/>.
     /// </summary>
-    public class ConsensusPreVoteMsg : ConsensusMsg
+    public class ConsensusPreVoteMsg : ConsensusVoteMsg
     {
         private static Bencodex.Codec _codec = new Bencodex.Codec();
 
@@ -55,17 +55,20 @@ public ConsensusPreVoteMsg(byte[][] dataframes)
         /// <inheritdoc cref="MessageContent.MessageType"/>
         public override MessageType Type => MessageType.ConsensusVote;
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(ConsensusMsg?)"/>
         public override bool Equals(ConsensusMsg? other)
         {
             return other is ConsensusPreVoteMsg message &&
                 PreVote.Equals(message.PreVote);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.Equals(object?)"/>
         public override bool Equals(object? obj)
         {
             return obj is ConsensusMsg other && Equals(other);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
         public override int GetHashCode()
         {
             return HashCode.Combine(Type, PreVote);
diff --git a/Libplanet.Net/Messages/ConsensusProposalMsg.cs b/Libplanet.Net/Messages/ConsensusProposalMsg.cs
index d55b599d7a5..de45ab198b6 100644
--- a/Libplanet.Net/Messages/ConsensusProposalMsg.cs
+++ b/Libplanet.Net/Messages/ConsensusProposalMsg.cs
@@ -8,7 +8,7 @@ namespace Libplanet.Net.Messages
     /// <summary>
     /// A message class for <see cref="ConsensusStep.Propose"/>.
     /// </summary>
-    public class ConsensusProposalMsg : ConsensusMsg
+    public class ConsensusProposalMsg : ConsensusVoteMsg
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ConsensusProposalMsg"/> class.
@@ -43,17 +43,20 @@ public ConsensusProposalMsg(byte[][] dataframes)
         /// <inheritdoc cref="MessageContent.MessageType"/>
         public override MessageType Type => MessageType.ConsensusProposal;
 
+        /// <inheritdoc cref="Equals(ConsensusMsg?)"/>
         public override bool Equals(ConsensusMsg? other)
         {
             return other is ConsensusProposalMsg message &&
                    message.Proposal.Equals(Proposal);
         }
 
+        /// <inheritdoc cref="Equals(object?)"/>
         public override bool Equals(object? obj)
         {
             return obj is ConsensusMsg other && Equals(other);
         }
 
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
         public override int GetHashCode()
         {
             return HashCode.Combine(Type, Proposal);
diff --git a/Libplanet.Net/Messages/ConsensusVoteMsg.cs b/Libplanet.Net/Messages/ConsensusVoteMsg.cs
new file mode 100644
index 00000000000..a0b5d2b647c
--- /dev/null
+++ b/Libplanet.Net/Messages/ConsensusVoteMsg.cs
@@ -0,0 +1,35 @@
+using Libplanet.Blocks;
+using Libplanet.Crypto;
+using Libplanet.Net.Consensus;
+
+namespace Libplanet.Net.Messages
+{
+    /// <summary>
+    /// A abstract base class message for consensus.
+    /// </summary>
+    public abstract class ConsensusVoteMsg : ConsensusMsg
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsensusMsg"/> class.
+        /// </summary>
+        /// <param name="validatorPublicKey">
+        /// A <see cref="PublicKey"/> of the validator who made this message.</param>
+        /// <param name="height">A <see cref="Context.Height"/> the message is for.</param>
+        /// <param name="round">A <see cref="Context.Round"/> the message is written for.</param>
+        /// <param name="blockHash">A <see cref="BlockHash"/> the message is written for.</param>
+        protected ConsensusVoteMsg(
+            PublicKey validatorPublicKey,
+            long height,
+            int round,
+            BlockHash blockHash)
+            : base(validatorPublicKey, height, round)
+        {
+            BlockHash = blockHash;
+        }
+
+        /// <summary>
+        /// A <see cref="BlockHash"/> the message is written for.
+        /// </summary>
+        public BlockHash BlockHash { get; }
+    }
+}
diff --git a/Libplanet.Net/Messages/ConsensusVoteSetBitsMsg.cs b/Libplanet.Net/Messages/ConsensusVoteSetBitsMsg.cs
index 8ae1bddee47..6d03c8a92d1 100644
--- a/Libplanet.Net/Messages/ConsensusVoteSetBitsMsg.cs
+++ b/Libplanet.Net/Messages/ConsensusVoteSetBitsMsg.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Libplanet.Blocks;
 using Libplanet.Consensus;
 
 namespace Libplanet.Net.Messages
@@ -18,10 +19,10 @@ public ConsensusVoteSetBitsMsg(VoteSetBits voteSetBits)
             : base(
                 voteSetBits.ValidatorPublicKey,
                 voteSetBits.Height,
-                voteSetBits.Round,
-                voteSetBits.BlockHash)
+                voteSetBits.Round)
         {
             VoteSetBits = voteSetBits;
+            BlockHash = voteSetBits.BlockHash;
         }
 
         /// <summary>
@@ -39,6 +40,11 @@ public ConsensusVoteSetBitsMsg(byte[][] dataframes)
         /// </summary>
         public VoteSetBits VoteSetBits { get; }
 
+        /// <summary>
+        /// A <see cref="BlockHash"/> of the message.
+        /// </summary>
+        public BlockHash BlockHash { get; }
+
         /// <inheritdoc cref="MessageContent.DataFrames"/>
         public override IEnumerable<byte[]> DataFrames =>
             new List<byte[]> { VoteSetBits.ToByteArray() };
diff --git a/Libplanet.Net/Messages/ConsensusVotesRecallMsg.cs b/Libplanet.Net/Messages/ConsensusVotesRecallMsg.cs
new file mode 100644
index 00000000000..2696b48cf3b
--- /dev/null
+++ b/Libplanet.Net/Messages/ConsensusVotesRecallMsg.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using Libplanet.Consensus;
+
+namespace Libplanet.Net.Messages
+{
+    /// <summary>
+    /// A message class for informing that peer is on bootstrapping.
+    /// </summary>
+    public class ConsensusVotesRecallMsg : ConsensusMsg
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsensusVotesRecallMsg"/> class.
+        /// </summary>
+        /// <param name="votesRecall">A <see cref="VotesRecall"/> information
+        /// of <see cref="Validator"/>.</param>
+        public ConsensusVotesRecallMsg(VotesRecall votesRecall)
+            : base(votesRecall.ValidatorPublicKey, votesRecall.Height, votesRecall.Round)
+        {
+            VotesRecall = votesRecall;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConsensusBootstrapMsg"/> class
+        /// with marshalled message.
+        /// </summary>
+        /// <param name="dataframes">A marshalled message.</param>
+        public ConsensusVotesRecallMsg(byte[][] dataframes)
+            : this(votesRecall: new VotesRecall(dataframes[0]))
+        {
+        }
+
+        /// <summary>
+        /// A <see cref="VotesRecall"/> of the message.
+        /// </summary>
+        public VotesRecall VotesRecall { get; }
+
+        /// <inheritdoc cref="MessageContent.DataFrames"/>
+        public override IEnumerable<byte[]> DataFrames =>
+            new List<byte[]> { VotesRecall.ToByteArray() };
+
+        /// <inheritdoc cref="MessageContent.MessageType"/>
+        public override MessageType Type => MessageType.VotesRecallMsg;
+
+        /// <inheritdoc cref="ConsensusMsg.Equals(ConsensusMsg?)"/>
+        public override bool Equals(ConsensusMsg? other)
+        {
+            return other is ConsensusVotesRecallMsg message &&
+                message.VotesRecall.Equals(VotesRecall);
+        }
+
+        /// <inheritdoc cref="ConsensusMsg.Equals(object?)"/>
+        public override bool Equals(object? obj)
+        {
+            return obj is ConsensusMsg other && Equals(other);
+        }
+
+        /// <inheritdoc cref="ConsensusMsg.GetHashCode"/>
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Type, VotesRecall);
+        }
+    }
+}
diff --git a/Libplanet.Net/Messages/MessageContent.cs b/Libplanet.Net/Messages/MessageContent.cs
index 1c2c910f399..bf5a5f528aa 100644
--- a/Libplanet.Net/Messages/MessageContent.cs
+++ b/Libplanet.Net/Messages/MessageContent.cs
@@ -121,6 +121,16 @@ public enum MessageType : byte
             /// </summary>
             ConsensusVoteSetBitsMsg = 0x46,
 
+            /// <summary>
+            /// Message that informs peer is on bootstrapping to other peer.
+            /// </summary>
+            BootstrapMsg = 0x47,
+
+            /// <summary>
+            /// Message that helps peer by recalling past votes.
+            /// </summary>
+            VotesRecallMsg = 0x48,
+
             /// <summary>
             /// List of message IDs that the peer seen recently.
             /// </summary>
diff --git a/Libplanet/Consensus/Bootstrap.cs b/Libplanet/Consensus/Bootstrap.cs
new file mode 100644
index 00000000000..e6e04ee9dd4
--- /dev/null
+++ b/Libplanet/Consensus/Bootstrap.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Bencodex;
+using Bencodex.Types;
+using Libplanet.Crypto;
+
+namespace Libplanet.Consensus
+{
+    /// <summary>
+    /// A class used to bootstrap <see cref="Validator"/>.
+    /// </summary>
+    public class Bootstrap : IEquatable<Bootstrap>
+    {
+        private static readonly byte[] SignatureKey = { 0x53 }; // 'S'
+        private static Codec _codec = new Codec();
+
+        private readonly BootstrapMetadata _bootstrapMetadata;
+
+        /// <summary>
+        /// Instantiates a <see cref="Bootstrap"/> with given <paramref name="bootstrapMetadata"/>
+        /// and its <paramref name="signature"/>.
+        /// </summary>
+        /// <param name="bootstrapMetadata">A <see cref="BootstrapMetadata"/> for bootstrapping.
+        /// </param>
+        /// <param name="signature">A signature signed with <paramref name="bootstrapMetadata"/>.
+        /// </param>
+        /// <exception cref="ArgumentNullException">Thrown if given <paramref name="signature"/> is
+        /// empty.</exception>
+        /// <exception cref="ArgumentException">Thrown if given <paramref name="signature"/> is
+        /// invalid and cannot be verified with <paramref name="bootstrapMetadata"/>.</exception>
+        public Bootstrap(BootstrapMetadata bootstrapMetadata, ImmutableArray<byte> signature)
+        {
+            _bootstrapMetadata = bootstrapMetadata;
+            Signature = signature;
+
+            if (signature.IsDefaultOrEmpty)
+            {
+                throw new ArgumentNullException(
+                    nameof(signature),
+                    "Signature cannot be null or empty.");
+            }
+            else if (!Verify())
+            {
+                throw new ArgumentException("Signature is invalid.", nameof(signature));
+            }
+        }
+
+        public Bootstrap(byte[] marshaled)
+            : this((Dictionary)_codec.Decode(marshaled))
+        {
+        }
+
+#pragma warning disable SA1118 // The parameter spans multiple lines
+        public Bootstrap(Dictionary encoded)
+            : this(
+                new BootstrapMetadata(encoded),
+                encoded.ContainsKey(SignatureKey)
+                    ? encoded.GetValue<Binary>(SignatureKey).ToImmutableArray()
+                    : ImmutableArray<byte>.Empty)
+        {
+        }
+#pragma warning restore SA1118
+
+        /// <inheritdoc cref="BootstrapMetadata.Height"/>
+        public long Height => _bootstrapMetadata.Height;
+
+        /// <inheritdoc cref="BootstrapMetadata.Round"/>
+        public int Round => _bootstrapMetadata.Round;
+
+        /// <inheritdoc cref="BootstrapMetadata.ValidatorPublicKey"/>
+        public PublicKey ValidatorPublicKey => _bootstrapMetadata.ValidatorPublicKey;
+
+        /// <inheritdoc cref="BootstrapMetadata.Timestamp"/>
+        public DateTimeOffset Timestamp => _bootstrapMetadata.Timestamp;
+
+        /// <summary>
+        /// A signature that signed with <see cref="Maj23Metadata"/>.
+        /// </summary>
+        public ImmutableArray<byte> Signature { get; }
+
+        /// <summary>
+        /// A Bencodex-encoded value of <see cref="Maj23"/>.
+        /// </summary>
+        [JsonIgnore]
+        public Dictionary Encoded =>
+            !Signature.IsEmpty
+                ? _bootstrapMetadata.Encoded.Add(SignatureKey, Signature)
+                : _bootstrapMetadata.Encoded;
+
+        /// <summary>
+        /// <see cref="byte"/> encoded <see cref="Maj23"/> data.
+        /// </summary>
+        public ImmutableArray<byte> ByteArray => ToByteArray().ToImmutableArray();
+
+        public byte[] ToByteArray() => _codec.Encode(Encoded);
+
+        /// <summary>
+        /// Verifies whether the <see cref="BootstrapMetadata"/> is properly signed by
+        /// <see cref="Validator"/>.
+        /// </summary>
+        /// <returns><see langword="true"/> if the <see cref="Signature"/> is not empty
+        /// and is a valid signature signed by <see cref="Validator"/>.</returns>
+        [Pure]
+        public bool Verify() =>
+            !Signature.IsDefaultOrEmpty &&
+            ValidatorPublicKey.Verify(
+                _bootstrapMetadata.ByteArray.ToImmutableArray(),
+                Signature);
+
+        /// <inheritdoc/>
+        [Pure]
+        public bool Equals(Bootstrap? other)
+        {
+            return other is { } bootstrap &&
+                   _bootstrapMetadata.Equals(bootstrap._bootstrapMetadata) &&
+                   Signature.SequenceEqual(bootstrap.Signature);
+        }
+
+        /// <inheritdoc/>
+        [Pure]
+        public override bool Equals(object? obj)
+        {
+            return obj is Bootstrap other && Equals(other);
+        }
+
+        /// <inheritdoc/>
+        [Pure]
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                _bootstrapMetadata.GetHashCode(),
+                ByteUtil.CalculateHashCode(Signature.ToArray()));
+        }
+    }
+}
diff --git a/Libplanet/Consensus/BootstrapMetadata.cs b/Libplanet/Consensus/BootstrapMetadata.cs
new file mode 100644
index 00000000000..fcb245f3112
--- /dev/null
+++ b/Libplanet/Consensus/BootstrapMetadata.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Text.Json.Serialization;
+using Bencodex;
+using Bencodex.Types;
+using Libplanet.Crypto;
+
+namespace Libplanet.Consensus
+{
+    public class BootstrapMetadata : IEquatable<BootstrapMetadata>
+    {
+        private const string TimestampFormat = "yyyy-MM-ddTHH:mm:ss.ffffffZ";
+        private static readonly byte[] HeightKey = { 0x48 };                // 'H'
+        private static readonly byte[] RoundKey = { 0x52 };                 // 'R'
+        private static readonly byte[] TimestampKey = { 0x74 };             // 't'
+        private static readonly byte[] ValidatorPublicKeyKey = { 0x50 };    // 'P'
+
+        private static Codec _codec = new Codec();
+
+        public BootstrapMetadata(
+            long height,
+            int round,
+            DateTimeOffset timestamp,
+            PublicKey validatorPublicKey)
+        {
+            if (height < 0)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(height),
+                    "Height must be greater than or equal to 0.");
+            }
+
+            if (round < 0)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(round),
+                    "Round must be greater than or equal to 0.");
+            }
+
+            Height = height;
+            Round = round;
+            Timestamp = timestamp;
+            ValidatorPublicKey = validatorPublicKey;
+        }
+
+#pragma warning disable SA1118 // The parameter spans multiple lines
+        public BootstrapMetadata(Dictionary encoded)
+            : this(
+                height: encoded.GetValue<Integer>(HeightKey),
+                round: encoded.GetValue<Integer>(RoundKey),
+                timestamp: DateTimeOffset.ParseExact(
+                    encoded.GetValue<Text>(TimestampKey),
+                    TimestampFormat,
+                    CultureInfo.InvariantCulture),
+                validatorPublicKey: new PublicKey(
+                    encoded.GetValue<Binary>(ValidatorPublicKeyKey).ByteArray))
+        {
+        }
+#pragma warning restore SA1118
+        /// <summary>
+        /// Current height of bootstrapping validator.
+        /// </summary>
+        public long Height { get; }
+
+        /// <summary>
+        /// Current round of bootstrapping validator.
+        /// </summary>
+        public int Round { get; }
+
+        /// <summary>
+        /// A <see cref="PublicKey"/> of bootstrapping validator.
+        /// </summary>
+        public PublicKey ValidatorPublicKey { get; }
+
+        /// <summary>
+        /// The time at which the bootstrapping requested.
+        /// </summary>
+        public DateTimeOffset Timestamp { get; }
+
+        /// <summary>
+        /// A Bencodex-encoded value of <see cref="BootstrapMetadata"/>.
+        /// </summary>
+        [JsonIgnore]
+        public Dictionary Encoded
+        {
+            get
+            {
+                Dictionary encoded = Bencodex.Types.Dictionary.Empty
+                    .Add(HeightKey, Height)
+                    .Add(RoundKey, Round)
+                    .Add(ValidatorPublicKeyKey, ValidatorPublicKey.Format(compress: true))
+                    .Add(
+                        TimestampKey,
+                        Timestamp.ToString(TimestampFormat, CultureInfo.InvariantCulture));
+
+                return encoded;
+            }
+        }
+
+        public ImmutableArray<byte> ByteArray => ToByteArray().ToImmutableArray();
+
+        public byte[] ToByteArray() => _codec.Encode(Encoded);
+
+        /// <summary>
+        /// Signs given <see cref="BootstrapMetadata"/> with given <paramref name="signer"/>.
+        /// </summary>
+        /// <param name="signer">A <see cref="PrivateKey"/> to sign.</param>
+        /// <returns>Returns a signed <see cref="Bootstrap"/>.</returns>
+        public Bootstrap Sign(PrivateKey signer) =>
+            new Bootstrap(this, signer.Sign(ByteArray).ToImmutableArray());
+
+        /// <inheritdoc/>
+        public bool Equals(BootstrapMetadata? other)
+        {
+            return other is { } metadata &&
+                Height == metadata.Height &&
+                Round == metadata.Round &&
+                ValidatorPublicKey.Equals(metadata.ValidatorPublicKey) &&
+                Timestamp
+                    .ToString(TimestampFormat, CultureInfo.InvariantCulture).Equals(
+                        metadata.Timestamp.ToString(
+                            TimestampFormat,
+                            CultureInfo.InvariantCulture));
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj) =>
+            obj is BootstrapMetadata other && Equals(other);
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                Height,
+                Round,
+                ValidatorPublicKey,
+                Timestamp.ToString(TimestampFormat, CultureInfo.InvariantCulture));
+        }
+    }
+}
diff --git a/Libplanet/Consensus/VotesRecall.cs b/Libplanet/Consensus/VotesRecall.cs
new file mode 100644
index 00000000000..724ddfe0668
--- /dev/null
+++ b/Libplanet/Consensus/VotesRecall.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Bencodex;
+using Bencodex.Types;
+using Libplanet.Crypto;
+
+namespace Libplanet.Consensus
+{
+    /// <summary>
+    /// A class used to help peer <see cref="Validator"/> to bootstrap by sending
+    /// <see cref="Vote"/>s that the peer has.
+    /// </summary>
+    public class VotesRecall : IEquatable<VotesRecall>
+    {
+        private static readonly byte[] SignatureKey = { 0x53 }; // 'S'
+        private static Codec _codec = new Codec();
+
+        private readonly VotesRecallMetadata _votesRecallMetadata;
+
+        /// <summary>
+        /// Instantiates a <see cref="VotesRecall"/> with given
+        /// <paramref name="votesRecallMetadata"/> and its <paramref name="signature"/>.
+        /// </summary>
+        /// <param name="votesRecallMetadata">
+        /// A <see cref="VotesRecallMetadata"/> to help bootstrapping.</param>
+        /// <param name="signature">A signature signed with <paramref name="votesRecallMetadata"/>.
+        /// </param>
+        /// <exception cref="ArgumentNullException">Thrown if given <paramref name="signature"/> is
+        /// empty.</exception>
+        /// <exception cref="ArgumentException">Thrown if given <paramref name="signature"/> is
+        /// invalid and cannot be verified with <paramref name="votesRecallMetadata"/>.</exception>
+        public VotesRecall(VotesRecallMetadata votesRecallMetadata, ImmutableArray<byte> signature)
+        {
+            _votesRecallMetadata = votesRecallMetadata;
+            Signature = signature;
+
+            if (signature.IsDefaultOrEmpty)
+            {
+                throw new ArgumentNullException(
+                    nameof(signature),
+                    "Signature cannot be null or empty.");
+            }
+            else if (!Verify())
+            {
+                throw new ArgumentException("Signature is invalid.", nameof(signature));
+            }
+        }
+
+        public VotesRecall(byte[] marshaled)
+            : this((Dictionary)_codec.Decode(marshaled))
+        {
+        }
+
+#pragma warning disable SA1118 // The parameter spans multiple lines
+        public VotesRecall(Dictionary encoded)
+            : this(
+                new VotesRecallMetadata(encoded),
+                encoded.ContainsKey(SignatureKey)
+                    ? encoded.GetValue<Binary>(SignatureKey).ToImmutableArray()
+                    : ImmutableArray<byte>.Empty)
+        {
+        }
+#pragma warning restore SA1118
+
+        /// <inheritdoc cref="VotesRecallMetadata.Height"/>
+        public long Height => _votesRecallMetadata.Height;
+
+        /// <inheritdoc cref="VotesRecallMetadata.Round"/>
+        public int Round => _votesRecallMetadata.Round;
+
+        /// <inheritdoc cref="VotesRecallMetadata.Timestamp"/>
+        public DateTimeOffset Timestamp => _votesRecallMetadata.Timestamp;
+
+        /// <inheritdoc cref="VotesRecallMetadata.ValidatorPublicKey"/>
+        public PublicKey ValidatorPublicKey => _votesRecallMetadata.ValidatorPublicKey;
+
+        /// <inheritdoc cref="VotesRecallMetadata.Votes"/>
+        public ImmutableHashSet<Vote> Votes => _votesRecallMetadata.Votes;
+
+        /// <summary>
+        /// A signature that signed with <see cref="VotesRecallMetadata"/>.
+        /// </summary>
+        public ImmutableArray<byte> Signature { get; }
+
+        /// <summary>
+        /// A Bencodex-encoded value of <see cref="VotesRecall"/>.
+        /// </summary>
+        [JsonIgnore]
+        public Dictionary Encoded =>
+            !Signature.IsEmpty
+                ? _votesRecallMetadata.Encoded.Add(SignatureKey, Signature)
+                : _votesRecallMetadata.Encoded;
+
+        /// <summary>
+        /// <see cref="byte"/> encoded <see cref="VotesRecall"/> data.
+        /// </summary>
+        public ImmutableArray<byte> ByteArray => ToByteArray().ToImmutableArray();
+
+        public byte[] ToByteArray() => _codec.Encode(Encoded);
+
+        /// <summary>
+        /// Verifies whether the <see cref="VotesRecallMetadata"/> is properly signed by
+        /// <see cref="Validator"/>.
+        /// </summary>
+        /// <returns><see langword="true"/> if the <see cref="Signature"/> is not empty
+        /// and is a valid signature signed by <see cref="Validator"/>.</returns>
+        [Pure]
+        public bool Verify() =>
+            !Signature.IsDefaultOrEmpty &&
+            ValidatorPublicKey.Verify(
+                _votesRecallMetadata.ByteArray.ToImmutableArray(),
+                Signature);
+
+        /// <inheritdoc/>
+        [Pure]
+        public bool Equals(VotesRecall? other)
+        {
+            return other is { } votesRecall &&
+                   _votesRecallMetadata.Equals(votesRecall._votesRecallMetadata) &&
+                   Signature.SequenceEqual(votesRecall.Signature);
+        }
+
+        /// <inheritdoc/>
+        [Pure]
+        public override bool Equals(object? obj)
+        {
+            return obj is VotesRecall other && Equals(other);
+        }
+
+        /// <inheritdoc/>
+        [Pure]
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                _votesRecallMetadata.GetHashCode(),
+                ByteUtil.CalculateHashCode(Signature.ToArray()));
+        }
+    }
+}
diff --git a/Libplanet/Consensus/VotesRecallMetadata.cs b/Libplanet/Consensus/VotesRecallMetadata.cs
new file mode 100644
index 00000000000..851967793ea
--- /dev/null
+++ b/Libplanet/Consensus/VotesRecallMetadata.cs
@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Bencodex;
+using Bencodex.Types;
+using Libplanet.Crypto;
+
+namespace Libplanet.Consensus
+{
+    public class VotesRecallMetadata : IEquatable<VotesRecallMetadata>
+    {
+        private const string TimestampFormat = "yyyy-MM-ddTHH:mm:ss.ffffffZ";
+        private static readonly byte[] HeightKey = { 0x48 };                // 'H'
+        private static readonly byte[] RoundKey = { 0x52 };                 // 'R'
+        private static readonly byte[] TimestampKey = { 0x74 };             // 't'
+        private static readonly byte[] ValidatorPublicKeyKey = { 0x50 };    // 'P'
+        private static readonly byte[] VotesKey = { 0x76 };                 // 'v'
+
+        private static Codec _codec = new Codec();
+
+        public VotesRecallMetadata(
+            long height,
+            int round,
+            DateTimeOffset timestamp,
+            PublicKey validatorPublicKey,
+            ImmutableHashSet<Vote> votes)
+        {
+            if (height < 0)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(height),
+                    "Height must be greater than or equal to 0.");
+            }
+
+            if (round < 0)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(round),
+                    "Round must be greater than or equal to 0.");
+            }
+
+            Height = height;
+            Round = round;
+            Timestamp = timestamp;
+            ValidatorPublicKey = validatorPublicKey;
+            Votes = votes;
+        }
+
+#pragma warning disable SA1118 // The parameter spans multiple lines
+        public VotesRecallMetadata(Dictionary encoded)
+            : this(
+                height: encoded.GetValue<Integer>(HeightKey),
+                round: encoded.GetValue<Integer>(RoundKey),
+                timestamp: DateTimeOffset.ParseExact(
+                    encoded.GetValue<Text>(TimestampKey),
+                    TimestampFormat,
+                    CultureInfo.InvariantCulture),
+                validatorPublicKey: new PublicKey(
+                    encoded.GetValue<Binary>(ValidatorPublicKeyKey).ByteArray),
+                votes: encoded.GetValue<List>(VotesKey).Select(
+                    v => new Vote(v)).ToImmutableHashSet())
+        {
+        }
+#pragma warning restore SA1118
+
+        /// <summary>
+        /// The height of given votes recall.
+        /// </summary>
+        public long Height { get; }
+
+        /// <summary>
+        /// The round of given votes recall.
+        /// </summary>
+        public int Round { get; }
+
+        /// <summary>
+        /// The time at which the votes recall took place.
+        /// </summary>
+        public DateTimeOffset Timestamp { get; }
+
+        /// <summary>
+        /// A <see cref="PublicKey"/> of <see cref="Validator"/>
+        /// that helps bootstrapping with votes recall.
+        /// </summary>
+        public PublicKey ValidatorPublicKey { get; }
+
+        /// <summary>
+        /// Set of recalled <see cref="Vote"/>s.
+        /// </summary>
+        public ImmutableHashSet<Vote> Votes { get; }
+
+        /// <summary>
+        /// A Bencodex-encoded value of <see cref="VotesRecallMetadata"/>.
+        /// </summary>
+        [JsonIgnore]
+        public Dictionary Encoded
+        {
+            get
+            {
+                Dictionary encoded = Bencodex.Types.Dictionary.Empty
+                    .Add(HeightKey, Height)
+                    .Add(RoundKey, Round)
+                    .Add(
+                        TimestampKey,
+                        Timestamp.ToString(TimestampFormat, CultureInfo.InvariantCulture))
+                    .Add(ValidatorPublicKeyKey, ValidatorPublicKey.Format(compress: true))
+                    .Add(
+                        VotesKey,
+                        new List(Votes.Select(v => v.Bencoded)));
+
+                return encoded;
+            }
+        }
+
+        public ImmutableArray<byte> ByteArray => ToByteArray().ToImmutableArray();
+
+        public byte[] ToByteArray() => _codec.Encode(Encoded);
+
+        /// <summary>
+        /// Signs given <see cref="VotesRecallMetadata"/> with given <paramref name="signer"/>.
+        /// </summary>
+        /// <param name="signer">A <see cref="PrivateKey"/> to sign.</param>
+        /// <returns>Returns a signed <see cref="VotesRecall"/>.</returns>
+        public VotesRecall Sign(PrivateKey signer) =>
+            new VotesRecall(this, signer.Sign(ByteArray).ToImmutableArray());
+
+        /// <inheritdoc/>
+        public bool Equals(VotesRecallMetadata? other)
+        {
+            return other is { } metadata &&
+                Height == metadata.Height &&
+                Round == metadata.Round &&
+                Timestamp
+                    .ToString(TimestampFormat, CultureInfo.InvariantCulture).Equals(
+                        metadata.Timestamp.ToString(
+                            TimestampFormat,
+                            CultureInfo.InvariantCulture)) &&
+                ValidatorPublicKey.Equals(metadata.ValidatorPublicKey) &&
+                Votes.SetEquals(metadata.Votes);
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj) =>
+            obj is VotesRecallMetadata other && Equals(other);
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                Height,
+                Round,
+                Timestamp.ToString(TimestampFormat, CultureInfo.InvariantCulture),
+                ValidatorPublicKey);
+        }
+    }
+}