diff --git a/CHANGES.md b/CHANGES.md
index e4835e57ecf..4cfdda36507 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -10,6 +10,10 @@ To be released.
     `IActionContext.From` properties to `Signer`.
     The corresponding parameter names on constructors and
     methods were also renamed too.
+ -  Old `Transaction<T>.Make()` factory method is replaced by
+    new `Transaction<T>.Create()` factory method.  The `timestamp` parameter
+    became optional, and the new optional `updatedAddresses` parameter was
+    added.
  -  Removed `IActionContext.To` property.
  -  Added `AccountStateGetter` delegate to provide a read-only view to
     account states.
diff --git a/Libplanet.Tests/Blockchain/BlockChainTest.cs b/Libplanet.Tests/Blockchain/BlockChainTest.cs
index 505c4b517d2..101e14b8b00 100644
--- a/Libplanet.Tests/Blockchain/BlockChainTest.cs
+++ b/Libplanet.Tests/Blockchain/BlockChainTest.cs
@@ -109,11 +109,9 @@ public void ProcessActions()
                     TargetAddress = _fx.Address1,
                 },
             };
-            Transaction<BaseAction> tx1 = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx1 = Transaction<BaseAction>.Create(
                 new PrivateKey(),
-                ImmutableHashSet.Create(_fx.Address1),
-                actions1,
-                DateTimeOffset.UtcNow
+                actions1
             );
 
             _blockChain.StageTransactions(new HashSet<Transaction<BaseAction>> { tx1 });
@@ -137,11 +135,9 @@ public void ProcessActions()
                     TargetAddress = _fx.Address1,
                 },
             };
-            Transaction<BaseAction> tx2 = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx2 = Transaction<BaseAction>.Create(
                 new PrivateKey(),
-                ImmutableHashSet.Create(_fx.Address1),
-                actions2,
-                DateTimeOffset.UtcNow
+                actions2
             );
 
             _blockChain.StageTransactions(new HashSet<Transaction<BaseAction>> { tx2 });
@@ -266,15 +262,9 @@ public void EvaluateActions()
             long blockIndex = 0;
 
             TestEvaluateAction action = new TestEvaluateAction();
-            Transaction<BaseAction> tx1 = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx1 = Transaction<BaseAction>.Create(
                 fromPrivateKey,
-                new[]
-                {
-                    TestEvaluateAction.SignerKey,
-                    TestEvaluateAction.BlockIndexKey,
-                }.ToImmutableHashSet(),
-                new[] { action },
-                DateTimeOffset.UtcNow
+                new[] { action }
             );
 
             _blockChain.StageTransactions(new HashSet<Transaction<BaseAction>> { tx1 });
diff --git a/Libplanet.Tests/Blocks/BlockTest.cs b/Libplanet.Tests/Blocks/BlockTest.cs
index b5239372593..25f33580417 100644
--- a/Libplanet.Tests/Blocks/BlockTest.cs
+++ b/Libplanet.Tests/Blocks/BlockTest.cs
@@ -186,21 +186,17 @@ public void EvaluateActions()
                 genesis,
                 new[]
                 {
-                    Transaction<BaseAction>.Make(
+                    Transaction<BaseAction>.Create(
                         _fx.TxFixture.PrivateKey,
-                        ImmutableHashSet<Address>.Empty,
                         new BaseAction[]
                         {
                             MakeAction(addresses[0], 'A'),
                             MakeAction(addresses[1], 'B'),
-                        },
-                        DateTimeOffset.UtcNow
+                        }
                     ),
-                    Transaction<BaseAction>.Make(
+                    Transaction<BaseAction>.Create(
                         _fx.TxFixture.PrivateKey,
-                        ImmutableHashSet<Address>.Empty,
-                        new BaseAction[] { MakeAction(addresses[2], 'C') },
-                        DateTimeOffset.UtcNow
+                        new BaseAction[] { MakeAction(addresses[2], 'C') }
                     ),
                 }
             );
@@ -233,17 +229,13 @@ public void EvaluateActions()
                 blockIdx1,
                 new[]
                 {
-                    Transaction<BaseAction>.Make(
+                    Transaction<BaseAction>.Create(
                         _fx.TxFixture.PrivateKey,
-                        ImmutableHashSet<Address>.Empty,
-                        new BaseAction[] { MakeAction(addresses[0], 'D') },
-                        DateTimeOffset.UtcNow
+                        new BaseAction[] { MakeAction(addresses[0], 'D') }
                     ),
-                    Transaction<BaseAction>.Make(
+                    Transaction<BaseAction>.Create(
                         _fx.TxFixture.PrivateKey,
-                        ImmutableHashSet<Address>.Empty,
-                        new BaseAction[] { MakeAction(addresses[3], 'E') },
-                        DateTimeOffset.UtcNow
+                        new BaseAction[] { MakeAction(addresses[3], 'E') }
                     ),
                 }
             );
@@ -345,11 +337,29 @@ public void ValidateInvalidTxPublicKey()
         [Fact]
         public void ValidateInvalidTxUpdatedAddresses()
         {
-            Transaction<BaseAction> invalidTx = Transaction<BaseAction>.Make(
-                _fx.TxFixture.PrivateKey,
-                ImmutableHashSet<Address>.Empty,
-                _fx.TxFixture.TxWithActions.Actions,
-                DateTimeOffset.UtcNow
+            ImmutableArray<IDictionary<string, object>> rawActions =
+                _fx.TxFixture.TxWithActions
+                    .ToRawTransaction(false).Actions.ToImmutableArray();
+            RawTransaction rawTxWithoutSig = new RawTransaction(
+                _fx.TxFixture.Address.ToByteArray(),
+                new byte[][] { },
+                _fx.TxFixture.PublicKey.Format(false),
+                DateTimeOffset.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.ffffffZ"),
+                rawActions,
+                new byte[0]
+            );
+            byte[] sig = _fx.TxFixture.PrivateKey.Sign(
+                new Transaction<BaseAction>(rawTxWithoutSig).ToBencodex(false)
+            );
+            var invalidTx = new Transaction<BaseAction>(
+                new RawTransaction(
+                    rawTxWithoutSig.Signer,
+                    rawTxWithoutSig.UpdatedAddresses,
+                    rawTxWithoutSig.PublicKey,
+                    rawTxWithoutSig.Timestamp,
+                    rawTxWithoutSig.Actions,
+                    sig
+                )
             );
             Block<BaseAction> invalidBlock = MineNext(
                 _fx.Next,
diff --git a/Libplanet.Tests/Common/Action/Sleep.cs b/Libplanet.Tests/Common/Action/Sleep.cs
index 29a4905c6a9..11fe07b3d3b 100644
--- a/Libplanet.Tests/Common/Action/Sleep.cs
+++ b/Libplanet.Tests/Common/Action/Sleep.cs
@@ -26,7 +26,11 @@ public override IAccountStateDelta Execute(IActionContext context)
         public override void LoadPlainValue(
             IImmutableDictionary<string, object> plainValue)
         {
-            ZoneId = (int)(BigInteger)plainValue["zone_id"];
+            object serialized = plainValue["zone_id"];
+
+            // FIXME: The reason why the type of the serialized value is not
+            // consistent should be analyzed.
+            ZoneId = serialized is BigInteger v ? (int)v : (int)serialized;
         }
     }
 }
diff --git a/Libplanet.Tests/Net/SwarmTest.cs b/Libplanet.Tests/Net/SwarmTest.cs
index 1a6b85c87ef..7795a4da1df 100644
--- a/Libplanet.Tests/Net/SwarmTest.cs
+++ b/Libplanet.Tests/Net/SwarmTest.cs
@@ -413,7 +413,7 @@ public async Task CanGetBlock()
         }
 
         [Fact]
-        public async Task CanGetTx()
+        public async Task GetTx()
         {
             Swarm swarmA = _swarms[0];
             Swarm swarmB = _swarms[1];
@@ -421,11 +421,9 @@ public async Task CanGetTx()
             BlockChain<BaseAction> chainA = _blockchains[0];
             BlockChain<BaseAction> chainB = _blockchains[1];
 
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 new PrivateKey(),
-                ImmutableHashSet<Address>.Empty,
-                new BaseAction[] { },
-                DateTimeOffset.UtcNow
+                new BaseAction[0]
             );
             chainB.StageTransactions(new[] { tx }.ToHashSet());
             chainB.MineBlock(_fx1.Address1);
@@ -457,7 +455,7 @@ public async Task CanGetTx()
         }
 
         [Fact]
-        public async Task CanBroadcastTx()
+        public async Task BroadcastTx()
         {
             Swarm swarmA = _swarms[0];
             Swarm swarmB = _swarms[1];
@@ -467,11 +465,9 @@ public async Task CanBroadcastTx()
             BlockChain<BaseAction> chainB = _blockchains[1];
             BlockChain<BaseAction> chainC = _blockchains[2];
 
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 new PrivateKey(),
-                ImmutableHashSet<Address>.Empty,
-                new BaseAction[] { },
-                DateTimeOffset.UtcNow
+                new BaseAction[] { }
             );
 
             chainA.StageTransactions(new[] { tx }.ToHashSet());
diff --git a/Libplanet.Tests/Store/FileStoreFixture.cs b/Libplanet.Tests/Store/FileStoreFixture.cs
index 4ae7ec59077..404cd120891 100644
--- a/Libplanet.Tests/Store/FileStoreFixture.cs
+++ b/Libplanet.Tests/Store/FileStoreFixture.cs
@@ -130,10 +130,10 @@ public void Dispose()
             var privateKey = new PrivateKey();
             var timestamp =
                 new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
-            return Transaction<BaseAction>.Make(
+            return Transaction<BaseAction>.Create(
                 privateKey,
-                updatedAddresses ?? ImmutableHashSet<Address>.Empty,
                 actions ?? new BaseAction[0],
+                updatedAddresses,
                 timestamp
             );
         }
diff --git a/Libplanet.Tests/Tx/TransactionTest.cs b/Libplanet.Tests/Tx/TransactionTest.cs
index 9c21ce72b12..41443b5ba7f 100644
--- a/Libplanet.Tests/Tx/TransactionTest.cs
+++ b/Libplanet.Tests/Tx/TransactionTest.cs
@@ -22,7 +22,7 @@ public TransactionTest()
         }
 
         [Fact]
-        public void Make()
+        public void Create()
         {
             var privateKey = new PrivateKey(
                 new byte[]
@@ -33,11 +33,12 @@ public void Make()
                     0x7b, 0x76,
                 }
             );
-            var timestamp = new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            var timestamp =
+                new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 privateKey,
-                ImmutableHashSet<Address>.Empty,
                 new BaseAction[0],
+                ImmutableHashSet<Address>.Empty,
                 timestamp
             );
 
@@ -73,24 +74,72 @@ public void Make()
                 ),
                 tx.Id
             );
+        }
+
+        [Fact]
+        public void CreateWithDefaultUpdatedAddresses()
+        {
+            Transaction<BaseAction> emptyTx = Transaction<BaseAction>.Create(
+                _fx.PrivateKey,
+                new BaseAction[0]
+            );
+            Assert.Empty(emptyTx.UpdatedAddresses);
 
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
+                _fx.PrivateKey,
+                _fx.TxWithActions.Actions
+            );
+            Assert.Equal(
+                new[] { _fx.Address }.ToImmutableHashSet(),
+                tx.UpdatedAddresses
+            );
+
+            Address additionalAddr = new PrivateKey().PublicKey.ToAddress();
+            Transaction<BaseAction> txWithAddr = Transaction<BaseAction>.Create(
+                _fx.PrivateKey,
+                _fx.TxWithActions.Actions,
+                new[] { additionalAddr }.ToImmutableHashSet()
+            );
+            Assert.Equal(
+                new[] { _fx.Address, additionalAddr }.ToHashSet(),
+                txWithAddr.UpdatedAddresses.ToHashSet()
+            );
+        }
+
+        [Fact]
+        public void CreateWithDefaultTimestamp()
+        {
+            DateTimeOffset rightBefore = DateTimeOffset.UtcNow;
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
+                _fx.PrivateKey,
+                new BaseAction[0],
+                ImmutableHashSet<Address>.Empty
+            );
+            DateTimeOffset rightAfter = DateTimeOffset.UtcNow;
+
+            Assert.InRange(tx.Timestamp, rightBefore, rightAfter);
+        }
+
+        [Fact]
+        public void CreateWithMissingRequiredArguments()
+        {
             // The privateKey parameter cannot be null.
             Assert.Throws<ArgumentNullException>(() =>
-                Transaction<BaseAction>.Make(
+                Transaction<BaseAction>.Create(
                     null,
-                    ImmutableHashSet<Address>.Empty,
                     new BaseAction[0],
-                    timestamp
+                    ImmutableHashSet<Address>.Empty,
+                    DateTimeOffset.UtcNow
                 )
             );
 
             // The actions parameter cannot be null.
             Assert.Throws<ArgumentNullException>(() =>
-                Transaction<BaseAction>.Make(
-                    privateKey,
-                    ImmutableHashSet<Address>.Empty,
+                Transaction<BaseAction>.Create(
+                    _fx.PrivateKey,
                     null,
-                    timestamp
+                    ImmutableHashSet<Address>.Empty,
+                    DateTimeOffset.UtcNow
                 )
             );
         }
@@ -214,7 +263,7 @@ public void MakeWithSignature()
         [Fact]
         public void ToBencodex()
         {
-            var expected = new byte[]
+            byte[] expected =
             {
                 0x64, 0x37, 0x3a, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
                 0x6c, 0x65, 0x31, 0x30, 0x3a, 0x70, 0x75, 0x62, 0x6c, 0x69,
@@ -513,9 +562,8 @@ public void Evaluate()
                 new PrivateKey().PublicKey.ToAddress(),
                 new PrivateKey().PublicKey.ToAddress(),
             };
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 _fx.PrivateKey,
-                ImmutableHashSet<Address>.Empty,
                 new BaseAction[]
                 {
                     new Attack
@@ -536,8 +584,7 @@ public void Evaluate()
                         Target = "t2",
                         TargetAddress = addresses[0],
                     },
-                },
-                DateTimeOffset.UtcNow
+                }
             );
             IAccountStateDelta delta = tx.EvaluateActions(
                 default,
@@ -573,11 +620,10 @@ public void Validate()
                 }
             );
             var timestamp = new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 privateKey,
-                ImmutableHashSet<Address>.Empty,
                 new BaseAction[0],
-                timestamp
+                timestamp: timestamp
             );
 
             tx.Validate();
@@ -646,11 +692,10 @@ public void ConvertToRaw()
                 }
             );
             var timestamp = new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
-            Transaction<BaseAction> tx = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> tx = Transaction<BaseAction>.Create(
                 privateKey,
-                ImmutableHashSet<Address>.Empty,
                 new BaseAction[0],
-                timestamp
+                timestamp: timestamp
             );
 
             Assert.Equal(
@@ -706,11 +751,9 @@ public void SignatureBufferIsIsolated()
         public void ActionsAreIsolatedFromOutside()
         {
             var actions = new List<BaseAction>();
-            Transaction<BaseAction> t1 = Transaction<BaseAction>.Make(
+            Transaction<BaseAction> t1 = Transaction<BaseAction>.Create(
                 _fx.PrivateKey,
-                ImmutableHashSet<Address>.Empty,
-                actions,
-                DateTimeOffset.UtcNow
+                actions
             );
             var t2 = new Transaction<BaseAction>(
                 _fx.PrivateKey.PublicKey.ToAddress(),
diff --git a/Libplanet.Tests/Tx/TxFixture.cs b/Libplanet.Tests/Tx/TxFixture.cs
index fc8c43cdfe0..0a466429c93 100644
--- a/Libplanet.Tests/Tx/TxFixture.cs
+++ b/Libplanet.Tests/Tx/TxFixture.cs
@@ -24,11 +24,10 @@ public TxFixture()
             var recipient = new Address(PrivateKey.PublicKey);
             var timestamp = new DateTimeOffset(2018, 11, 21, 0, 0, 0, TimeSpan.Zero);
 
-            Tx = Transaction<BaseAction>.Make(
+            Tx = Transaction<BaseAction>.Create(
                 PrivateKey,
-                ImmutableHashSet<Address>.Empty,
                 new BaseAction[0],
-                timestamp
+                timestamp: timestamp
             );
             BaseAction[] actions =
             {
@@ -43,11 +42,10 @@ public TxFixture()
                     ZoneId = 10,
                 },
             };
-            TxWithActions = Transaction<BaseAction>.Make(
+            TxWithActions = Transaction<BaseAction>.Create(
                 PrivateKey,
-                ImmutableHashSet.Create(recipient),
                 actions,
-                timestamp
+                timestamp: timestamp
             );
         }
 
diff --git a/Libplanet/Tx/Transaction.cs b/Libplanet/Tx/Transaction.cs
index e6d6ba19a36..0bc038e75d7 100644
--- a/Libplanet/Tx/Transaction.cs
+++ b/Libplanet/Tx/Transaction.cs
@@ -11,6 +11,7 @@
 using Libplanet.Action;
 using Libplanet.Crypto;
 using Libplanet.Serialization;
+using Uno.Extensions;
 
 namespace Libplanet.Tx
 {
@@ -40,6 +41,14 @@ public class Transaction<T> : ISerializable, IEquatable<Transaction<T>>
 
         /// <summary>
         /// Creates a new <see cref="Transaction{T}"/>.
+        /// <para>This constructor takes all required and only required values
+        /// for a <see cref="Transaction{T}"/>, so gives you full control of
+        /// creating a <see cref="Transaction{T}"/>, and in other words,
+        /// this constructor is only useful when all details of
+        /// a <see cref="Transaction{T}"/> need to be manually adjusted.
+        /// For the most cases, the fa&#xe7;ade factory <see
+        /// cref="Create(PrivateKey, IEnumerable{T}, IImmutableSet{Address},
+        /// DateTimeOffset?)"/> is more useful.</para>
         /// </summary>
         /// <param name="signer">An <see cref="Address"/> of the account
         /// who signs this transaction.  If this is not derived from <paramref
@@ -229,40 +238,87 @@ public static Transaction<T> FromBencodex(byte[] bytes)
         /// A fa&#xe7;ade factory to create a new <see cref="Transaction{T}"/>.
         /// Unlike the <see cref="Transaction(Address, PublicKey,
         /// IImmutableSet{Address}, DateTimeOffset, IEnumerable{T}, byte[])"/>
-        /// constructor, it automatically signs,
-        /// and fills the appropriate <see cref="Signer"/> and
-        /// <see cref="PublicKey"/> properties using the given
-        /// <paramref name="privateKey"/>.  However, the <paramref
-        /// name="privateKey"/> in itself is not included in the created
-        /// <see cref="Transaction{T}"/>.
+        /// constructor, it automatically fills the following values from:
+        /// <list type="table">
+        /// <listheader>
+        /// <term>Property</term>
+        /// <description>Parameter the filled value derived from</description>
+        /// </listheader>
+        /// <item>
+        /// <term><see cref="Signer"/></term>
+        /// <description><paramref name="privateKey"/></description>
+        /// </item>
+        /// <item>
+        /// <term><see cref="PublicKey"/></term>
+        /// <description><paramref name="privateKey"/></description>
+        /// </item>
+        /// <item>
+        /// <term><see cref="UpdatedAddresses"/></term>
+        /// <description><paramref name="actions"/> and
+        /// <paramref name="updatedAddresses"/></description>
+        /// </item>
+        /// </list>
+        /// <para>Note that the <paramref name="privateKey"/> in itself is not
+        /// included in the created <see cref="Transaction{T}"/>.</para>
         /// </summary>
+        /// <remarks>
+        /// This factory method tries its best to fill the <see
+        /// cref="UpdatedAddresses"/> property by actually evaluating
+        /// the given <paramref name="actions"/>, but remember that its result
+        /// is approximated in some degree, because the result of
+        /// <paramref name="actions"/> are not deterministic until
+        /// the <see cref="Transaction{T}"/> belongs to a <see
+        /// cref="Libplanet.Blocks.Block{T}"/>.
+        /// <para>If an <see cref="IAction"/> depends on previous states or
+        /// some randomness to determine what <see cref="Address"/> to update,
+        /// the automatically filled <see cref="UpdatedAddresses"/> became
+        /// mismatched from the <see cref="Address"/>es
+        /// <paramref name="actions"/> actually update after
+        /// a <see cref="Libplanet.Blocks.Block{T}"/> is mined.
+        /// Although such case would be rare, a programmer could manually give
+        /// the <paramref name="updatedAddresses"/> parameter
+        /// the <see cref="Address"/>es they predict to be updated.</para>
+        /// <para>If an <see cref="IAction"/> oversimplifies the assumption
+        /// about the <see cref="Libplanet.Blocks.Block{T}"/> it belongs to,
+        /// runtime exceptions could be thrown from this factory method.
+        /// Only solution to that is not to oversimplify things.</para>
+        /// </remarks>
         /// <param name="privateKey">A <see cref="PrivateKey"/> of the account
         /// who creates and signs a new transaction.  This key is used to fill
         /// the <see cref="Signer"/>, <see cref="PublicKey"/>, and
         /// <see cref="Signature"/> properties, but this in itself is not
         /// included in the transaction.</param>
-        /// <param name="updatedAddresses"><see cref="Address"/>es whose
-        /// states affected by <paramref name="actions"/>.  This goes to
-        /// the <see cref="UpdatedAddresses"/> property.</param>
         /// <param name="actions">A list of <see cref="IAction"/>s.  This
         /// can be empty, but cannot be <c>null</c>.  This goes to
-        /// the <see cref="Actions"/> property.</param>
+        /// the <see cref="Actions"/> property, and <see cref="IAction"/>s
+        /// are evaluated before a <see cref="Transaction{T}"/> is created
+        /// in order to fill the <see cref="UpdatedAddresses"/>.  See also
+        /// <em>Remarks</em> section.</param>
+        /// <param name="updatedAddresses"><see cref="Address"/>es whose
+        /// states affected by <paramref name="actions"/>.
+        /// These <see cref="Address"/>es are also included in
+        /// the <see cref="UpdatedAddresses"/> property, besides
+        /// <see cref="Address"/>es projected by evaluating
+        /// <paramref name="actions"/>.  See also <em>Remarks</em> section.
+        /// </param>
         /// <param name="timestamp">The time this <see cref="Transaction{T}"/>
         /// is created and signed.  This goes to the <see cref="Timestamp"/>
-        /// property.</param>
+        /// property.  If <c>null</c> (which is default) is passed this will
+        /// be the current time.</param>
         /// <returns>A created new <see cref="Transaction{T}"/> signed by
         /// the given <paramref name="privateKey"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when <c>null</c>
         /// is passed to <paramref name="privateKey"/> or
         /// or <paramref name="actions"/>.
         /// </exception>
-        public static Transaction<T> Make(
+        public static Transaction<T> Create(
             PrivateKey privateKey,
-            IImmutableSet<Address> updatedAddresses,
             IEnumerable<T> actions,
-            DateTimeOffset timestamp)
+            IImmutableSet<Address> updatedAddresses = null,
+            DateTimeOffset? timestamp = null
+        )
         {
-            if (privateKey == null)
+            if (ReferenceEquals(privateKey, null))
             {
                 throw new ArgumentNullException(nameof(privateKey));
             }
@@ -270,20 +326,57 @@ public static Transaction<T> FromBencodex(byte[] bytes)
             PublicKey publicKey = privateKey.PublicKey;
             var signer = new Address(publicKey);
 
-            var tx = new Transaction<T>(
+            if (ReferenceEquals(updatedAddresses, null))
+            {
+                updatedAddresses = ImmutableHashSet<Address>.Empty;
+            }
+
+            DateTimeOffset ts = timestamp ?? DateTimeOffset.UtcNow;
+
+            ImmutableArray<T> actionsArray = actions.ToImmutableArray();
+            byte[] payload = new Transaction<T>(
                 signer,
                 publicKey,
                 updatedAddresses,
-                timestamp,
-                actions
-            );
+                ts,
+                actionsArray
+            ).ToBencodex(false);
+
+            if (!actionsArray.IsEmpty)
+            {
+                IAccountStateDelta delta = new Transaction<T>(
+                    signer,
+                    publicKey,
+                    updatedAddresses,
+                    ts,
+                    actionsArray
+                ).EvaluateActions(
+                    default(HashDigest<SHA256>),
+                    0,
+                    new AccountStateDeltaImpl(_ => null)
+                );
+                if (!updatedAddresses.IsSupersetOf(delta.UpdatedAddresses))
+                {
+                    updatedAddresses =
+                        updatedAddresses.Union(delta.UpdatedAddresses);
+                    payload = new Transaction<T>(
+                        signer,
+                        publicKey,
+                        updatedAddresses,
+                        ts,
+                        actionsArray
+                    ).ToBencodex(false);
+                }
+            }
+
+            byte[] sig = privateKey.Sign(payload);
             return new Transaction<T>(
                 signer,
                 publicKey,
                 updatedAddresses,
-                timestamp,
-                actions,
-                privateKey.Sign(tx.ToBencodex(false))
+                ts,
+                actionsArray,
+                sig
             );
         }
 
@@ -348,7 +441,7 @@ IAccountStateDelta previousStates
         {
             int seed =
                 BitConverter.ToInt32(blockHash.ToByteArray(), 0) ^
-                BitConverter.ToInt32(Signature, 0);
+                (Signature.Empty() ? 0 : BitConverter.ToInt32(Signature, 0));
             IAccountStateDelta states = previousStates;
             foreach (T action in Actions)
             {