Feature chain context

AElf.Kernel.Modules.AutofacModule/Module.cs

@@ -1,5 +1,4 @@
-using System;
-using Autofac;
+using Autofac;
 
 namespace AElf.Kernel.Modules.AutofacModule
 {

AElf.Kernel.Tests/AccountContextTest.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using Xunit.Frameworks.Autofac;
+
+namespace AElf.Kernel.Tests
+{
+    [UseAutofacTestFramework]
+    public class AccountContextTest
+    {
+        private readonly AccountContextService _accountContextService;
+
+        public AccountContextTest(AccountContextService accountContextService)
+        {
+            _accountContextService = accountContextService;
+        }
+
+        [Fact]
+        public void GetAccountContextTest()
+        {
+            var chainId = Hash.Generate();
+            var accountId = Hash.Generate();
+
+            var context1 = _accountContextService.GetAccountDataContext(accountId, chainId);
+            var context2 = _accountContextService.GetAccountDataContext(accountId, chainId);
+            Assert.Equal(context1, context2);
+
+            context1.IncreasementId++;
+            var context3 = _accountContextService.GetAccountDataContext(accountId, chainId);
+            Assert.Equal(context1, context3);
+            Assert.Equal(context3.IncreasementId, (ulong)1);
+        }
+
+    }
+}

AElf.Kernel.Tests/BlockTest.cs

@@ -0,0 +1,54 @@
+using System.Threading.Tasks;
+using AElf.Kernel.KernelAccount;
+using Xunit;
+using Xunit.Frameworks.Autofac;
+
+namespace AElf.Kernel.Tests
+{
+    [UseAutofacTestFramework]
+    public class BlockTest
+    {
+        private IBlockManager _blockManager;
+        private ISmartContractZero _smartContractZero;
+        private ChainTest _chainTest;
+
+
+        public BlockTest(IBlockManager blockManager, ISmartContractZero smartContractZero, ChainTest chainTest)
+        {
+            _blockManager = blockManager;
+            _smartContractZero = smartContractZero;
+            _chainTest = chainTest;
+        }
+
+
+
+       [Fact]
+        public void GenesisBlockBuilderTest()
+        {
+            var builder = new GenesisBlockBuilder().Build(_smartContractZero.GetType());
+            var genesisBlock = builder.Block;
+            var txs = builder.Txs;
+            Assert.NotNull(genesisBlock);
+            Assert.Equal(genesisBlock.Header.PreviousHash, Hash.Zero);
+            Assert.NotNull(txs);
+        }
+
+        [Fact]
+        public async Task BlockManagerTest()
+        {
+            var builder = new GenesisBlockBuilder().Build(_smartContractZero.GetType());
+            var genesisBlock = builder.Block;
+
+            await _blockManager.AddBlockAsync(genesisBlock);
+            var blockHeader = await _blockManager.GetBlockHeaderAsync(genesisBlock.GetHash());
+
+            var block = new Block(genesisBlock.GetHash());
+
+            var chain = await _chainTest.CreateChainTest();
+            await _chainTest.AppendBlockTest(chain, block);
+            Assert.Equal(blockHeader, genesisBlock.Header);
+        }
+
+
+    }
+}

AElf.Kernel.Tests/ChainTest.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Threading.Tasks;
+using AElf.Kernel.KernelAccount;
+using Xunit;
+using Xunit.Frameworks.Autofac;
+
+namespace AElf.Kernel.Tests
+{
+    [UseAutofacTestFramework]
+    public class ChainTest
+    {
+        private readonly IChainCreationService _chainCreationService;
+        private readonly ISmartContractZero _smartContractZero;
+        private readonly IChainManager _chainManager;
+        private readonly IChainContextService _chainContextService;
+
+        public ChainTest(ISmartContractZero smartContractZero, IChainCreationService chainCreationService,
+            IChainManager chainManager, IChainContextService chainContextService)
+        {
+            _smartContractZero = smartContractZero;
+            _chainCreationService = chainCreationService;
+            _chainManager = chainManager;
+            _chainContextService = chainContextService;
+        }
+
+        [Fact]
+        public async Task<Chain> CreateChainTest()
+        {
+            var chainId = Hash.Generate();
+            var chain = await _chainCreationService.CreateNewChainAsync(chainId, _smartContractZero.GetType());
+            var adp = new AccountDataProvider
+            {
+                Context =
+                {
+                    Address = new Hash(new byte[] {1, 2, 3}),
+                    ChainId = chainId
+                }
+            };
+            await _smartContractZero.InitializeAsync(adp);
+            Assert.Equal(chain.CurrentBlockHeight, (ulong)1);
+            return chain;
+        }
+
+        public async Task ChainStoreTest(Hash chainId)
+        {
+            await _chainManager.AddChainAsync(chainId);
+            Assert.NotNull(_chainManager.GetChainAsync(chainId).Result);
+        }
+
+        public async Task ChainContextTest()
+        {
+            var chain = await CreateChainTest();
+            await _chainManager.AddChainAsync(chain.Id);
+            chain = await _chainManager.GetChainAsync(chain.Id);
+            var context = _chainContextService.GetChainContext(chain.Id);
+            Assert.NotNull(context);
+            Assert.Equal(context.SmartContractZero, _smartContractZero);
+        }
+
+        public async Task AppendBlockTest(Chain chain, Block block)
+        {
+            await _chainManager.AppendBlockToChainAsync(chain, block);
+            Assert.Equal(chain.CurrentBlockHeight, (ulong)2);
+            Assert.Equal(chain.CurrentBlockHash, block.GetHash());
+        }
+    }
+}

AElf.Kernel.Tests/TransactionSchedulerTest.cs

@@ -35,14 +35,14 @@ private IAccount CreateAccount(byte b)
             return account.Object;
         }
 
-        private List<IAccount> CreateAccountList(int accountCount)
+        private List<Hash> CreateHashList(int accountCount)
         {
-            List<IAccount> accounts = new List<IAccount>();
+            List<Hash> hashes = new List<Hash>();
             for (int j = 0; j < accountCount; j++)
             {
-                accounts.Add(CreateAccount((byte)(j + 'a')));
+                hashes.Add(CreateHash((byte)(j + 'a')).Object);
             }
-            return accounts;
+            return hashes;
         }
 
 
@@ -64,29 +64,25 @@ private ITransaction CreateTransaction(byte b, Hash from, Hash to)
             return transaction.Object;
         }
 
-        /*
+
         [Fact]
         public void SchedulerTest()
         {
 
-            var worldState = new WorldState();
-            var smartContractZero = new SmartContractZero();
-            var accountZero = new AccountZero(smartContractZero);
-            var accountManager = new AccountManager(worldState);
-            ISmartContractManager sm = null;
-            var transactionExecutingManager = new TransactionExecutingManager(worldState, accountZero, accountManager,sm);
+            ISmartContractService sm = null;
+            IChainContext context = null;
+            var transactionExecutingManager = new TransactionExecutingManager(sm);
 
             // simple demo cases
 
-
-            var accounts = CreateAccountList(10);
+            var accounts = CreateHashList(10);
             // one tx
             // A
             var tx1 = CreateTransaction((byte) 'A', accounts[0], accounts[1]);
 
             var transactions = new List<ITransaction> {tx1};
 
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
 
             var plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(1, plan.Count);
@@ -98,7 +94,7 @@ public void SchedulerTest()
             // A B
             var tx2 = CreateTransaction((byte) 'B', accounts[2], accounts[3] );
             transactions = new List<ITransaction>{tx1, tx2};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(1, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -111,7 +107,7 @@ public void SchedulerTest()
             // A-B
             tx2 = CreateTransaction((byte) 'B', accounts[0], accounts[1] );
             transactions = new List<ITransaction>{tx1, tx2};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -127,7 +123,7 @@ public void SchedulerTest()
             // A-B C
             var tx3 = CreateTransaction((byte) 'C', accounts[2], accounts[3]);
             transactions = new List<ITransaction>{tx1, tx2, tx3};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -139,7 +135,7 @@ public void SchedulerTest()
             tx2 = CreateTransaction((byte) 'B', accounts[1], accounts[2]);
             tx3 = CreateTransaction((byte) 'C', accounts[2], accounts[3]);
             transactions = new List<ITransaction>{tx1, tx2, tx3};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -153,7 +149,7 @@ public void SchedulerTest()
 
             tx3 = CreateTransaction((byte) 'C', accounts[0], accounts[2]);
             transactions = new List<ITransaction>{tx1, tx2, tx3};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(3, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -169,7 +165,7 @@ public void SchedulerTest()
             tx3 = CreateTransaction((byte) 'C', accounts[3], accounts[4]);
             var tx4 = CreateTransaction((byte) 'D', accounts[5], accounts[6]);
             transactions = new List<ITransaction>{tx1, tx2, tx3, tx4};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -185,7 +181,7 @@ public void SchedulerTest()
             tx4 = CreateTransaction((byte) 'D', accounts[4], accounts[5]);
 
             transactions = new List<ITransaction>{tx1, tx2, tx3, tx4};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -212,7 +208,7 @@ public void SchedulerTest()
             tx4 = CreateTransaction((byte) 'D', accounts[3], accounts[0]);
 
             transactions = new List<ITransaction>{tx1, tx2, tx3, tx4};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(2, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -230,7 +226,7 @@ public void SchedulerTest()
             tx4 = CreateTransaction((byte) 'D', accounts[3], accounts[0]);
 
             transactions = new List<ITransaction>{tx1, tx2, tx3, tx4};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(3, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -246,7 +242,7 @@ public void SchedulerTest()
             tx4 = CreateTransaction((byte) 'D', accounts[0], accounts[1]);
 
             transactions = new List<ITransaction>{tx1, tx2, tx3, tx4};
-            transactionExecutingManager.Schedule(transactions);
+            transactionExecutingManager.Schedule(transactions, context);
             plan = transactionExecutingManager.ExecutingPlan;
             Assert.Equal(4, plan.Count);
             Assert.Equal(65, plan[0].ElementAt(0).GetHash().GetHashBytes()[0]);
@@ -255,7 +251,7 @@ public void SchedulerTest()
             Assert.Equal(68, plan[3].ElementAt(0).GetHash().GetHashBytes()[0]);
 
         }
-*/
+
 
     }
 }

AElf.Kernel/Account.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace AElf.Kernel
 {
@@ -29,4 +29,4 @@ public Hash GetAddress()
             return Address;
         }
     }
-}
+}

AElf.Kernel/Block.cs

@@ -39,7 +39,7 @@ public void FillTxsMerkleTreeRootInHeader()
         /// <returns>The hash.</returns>
         public Hash GetHash()
         {
-            return new Hash(this.Header.CalculateHash());
+            return Header.Hash;
         }
     }
 }

AElf.Kernel/BlockHeader.cs

@@ -25,6 +25,14 @@ public BlockHeader(Hash preBlockHash)
 
 
         public Hash PreviousHash { get; set; }
+
+        public Hash Hash => new Hash(this.CalculateHash());
+
+        /// <summary>
+        /// block index in chain
+        /// </summary>
+        public ulong Index { get; set;}
+