public async Task Request_SideChain_Creation_Twice()
{
await InitializeCrossChainContract();
long lockedTokenAmount = 20;
await ApproveBalance(lockedTokenAmount * 2);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var tx = await GenerateTransactionAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
null,
sideChainCreationRequest);
await MineAsync(new List <Transaction> {
tx
});
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var expectedChainId = ChainHelpers.GetChainId(2);
Assert.Equal(expectedChainId, RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
Configure <ChainOptions>(o => { o.ChainId = ChainHelpers.ConvertBase58ToChainId("AELF"); });
var ecKeyPair = CryptoHelpers.GenerateKeyPair();
var nodeAccount = Address.FromPublicKey(ecKeyPair.PublicKey).GetFormatted();
var nodeAccountPassword = "******";
Configure <AccountOptions>(o =>
{
o.NodeAccount = nodeAccount;
o.NodeAccountPassword = nodeAccountPassword;
});
context.Services.AddSingleton <IKeyStore>(o =>
{
var keyStore = new Mock <IKeyStore>();
ECKeyPair keyPair = null;
keyStore.Setup(k => k.GetAccountKeyPair(It.IsAny <string>())).Returns(() => keyPair);
keyStore.Setup(k => k.OpenAsync(It.IsAny <string>(), It.IsAny <string>(), false)).Returns(() =>
{
keyPair = ecKeyPair;
return(Task.FromResult(AElfKeyStore.Errors.None));
});
return(keyStore.Object);
});
context.Services.AddTransient <AccountService>();
}
public async Task Request_SideChain_Creation()
{
await InitializeCrossChainContract();
long lockedTokenAmount = 10;
await ApproveBalance(lockedTokenAmount);
var balanceResult = GetBalanceOutput.Parser.ParseFrom(await Tester.CallContractMethodAsync(TokenContractAddress, nameof(TokenContract.GetBalance),
new GetBalanceInput
{
Owner = Address.FromPublicKey(Tester.KeyPair.PublicKey),
Symbol = "ELF"
}));
Assert.Equal(_balanceOfStarter, balanceResult.Balance);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var txResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Mined);
var expectedChainId = ChainHelpers.GetChainId(1);
Assert.Equal(expectedChainId, RequestChainCreationOutput.Parser.ParseFrom(txResult.ReturnValue).ChainId);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var services = context.Services;
services.AddKeyValueDbContext <BlockchainKeyValueDbContext>(o => o.UseInMemoryDatabase());
services.AddKeyValueDbContext <StateKeyValueDbContext>(o => o.UseInMemoryDatabase());
services.AddTransient <IGenesisSmartContractDtoProvider, GenesisSmartContractDtoProvider>();
services.TryAddSingleton <ISmartContractAddressNameProvider, ConsensusSmartContractAddressNameProvider>();
services.TryAddSingleton <ISmartContractAddressNameProvider, ElectionSmartContractAddressNameProvider>();
services.TryAddSingleton <ISmartContractAddressNameProvider, ProfitSmartContractAddressNameProvider>();
services.TryAddSingleton <ISmartContractAddressNameProvider, TokenSmartContractAddressNameProvider>();
services.TryAddSingleton <ISmartContractAddressNameProvider, VoteSmartContractAddressNameProvider>();
Configure <ChainOptions>(options =>
{
options.ChainId =
ChainHelpers.ConvertBase58ToChainId(context.Services.GetConfiguration()["ChainId"]);
});
Configure <HostSmartContractBridgeContextOptions>(options =>
{
options.ContextVariables[ContextVariableDictionary.NativeSymbolName] = Symbol;
});
}
public async Task Get_SideChain_Height()
{
long lockedTokenAmount = 10;
await InitializeCrossChainContract();
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var tx1 = await GenerateTransactionAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest);
await MineAsync(new List <Transaction> {
tx1
});
var chainId = ChainHelpers.GetChainId(1);
await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.CreateSideChain),
new SInt32Value()
{
Value = chainId
});
var height = SInt64Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress,
nameof(CrossChainContract.GetSideChainHeight),
new SInt32Value()
{
Value = chainId
})).Value;
Assert.True(height == 0);
}
public async Task GetChainStatus_Review()
{
long lockedTokenAmount = 10;
await InitializeCrossChainContract();
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var tx1 = await GenerateTransactionAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation), null, sideChainCreationRequest);
await MineAsync(new List <Transaction> {
tx1
});
var chainId = ChainHelpers.GetChainId(1);
var status = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress,
nameof(CrossChainContract.GetChainStatus),
new SInt32Value()
{
Value = chainId
})).Value;
Assert.Equal(1, status);
}
public async Task <bool> StartIndexingRequest(int chainId, long targetHeight,
ICrossChainDataProducer crossChainDataProducer)
{
var requestData = new RequestCrossChainBlockData
{
FromChainId = LocalChainId,
NextHeight = targetHeight
};
using (var serverStream = RequestIndexing(requestData))
{
while (await serverStream.ResponseStream.MoveNext())
{
var response = serverStream.ResponseStream.Current;
// requestCrossChain failed or useless response
if (!response.Success || !crossChainDataProducer.AddNewBlockInfo(response.BlockInfoResult))
{
break;
}
crossChainDataProducer.Logger.LogTrace(
$"Received response from chain {ChainHelpers.ConvertChainIdToBase58(response.BlockInfoResult.ChainId)} at height {response.Height}");
}
}
return(true);
}
public async Task <List <SideChainBlockData> > GetSideChainBlockDataAsync(Hash currentBlockHash, long currentBlockHeight)
{
var sideChainBlockData = new List <SideChainBlockData>();
var dict = await _crossChainContractReader.GetSideChainIdAndHeightAsync(currentBlockHash,
currentBlockHeight);
foreach (var idHeight in dict)
{
var i = 0;
var targetHeight = idHeight.Value + 1;
while (i < CrossChainConstants.MaximalCountForIndexingSideChainBlock)
{
var blockInfo = _crossChainDataConsumer.TryTake <SideChainBlockData>(idHeight.Key, targetHeight, true);
if (blockInfo == null)
{
// no more available parent chain block info
break;
}
sideChainBlockData.Add(blockInfo);
Logger.LogTrace($"Got height {blockInfo.Height} of side chain {ChainHelpers.ConvertChainIdToBase58(idHeight.Key)}");
targetHeight++;
i++;
}
}
Logger.LogTrace($"Side chain block data count {sideChainBlockData.Count}");
return(sideChainBlockData);
}
public async Task RechargeForSideChain_ChainNoExist()
{
var parentChainId = 123;
long lockedTokenAmount = 10;
await InitializeCrossChainContract(parentChainId);
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty);
var requestTxResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
var chainId = RequestChainCreationOutput.Parser.ParseFrom(requestTxResult.ReturnValue).ChainId;
var otherChainId = ChainHelpers.GetChainId(5);
var rechargeInput = new RechargeInput()
{
ChainId = otherChainId,
Amount = 100_000L
};
await ApproveBalance(100_000L);
var transactionResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress, nameof(CrossChainContract.Recharge),
rechargeInput);
transactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
transactionResult.Error.Contains("Side chain not found or not able to be recharged.").ShouldBeTrue();
}
public async Task Get_Block_By_BlockHash_Success()
{
var chain = await _blockchainService.GetChainAsync();
var transactions = new List <Transaction>();
for (int i = 0; i < 3; i++)
{
transactions.Add(await _osTestHelper.GenerateTransferTransaction());
}
await _osTestHelper.BroadcastTransactions(transactions);
var block = await _osTestHelper.MinedOneBlock();
var response =
await GetResponseAsObjectAsync <BlockDto>(
$"/api/blockChain/block?blockHash={block.GetHash().ToHex()}&includeTransactions=true");
response.BlockHash.ShouldBe(block.GetHash().ToHex());
response.Header.PreviousBlockHash.ShouldBe(block.Header.PreviousBlockHash.ToHex());
response.Header.MerkleTreeRootOfTransactions.ShouldBe(block.Header.MerkleTreeRootOfTransactions.ToHex());
response.Header.MerkleTreeRootOfWorldState.ShouldBe(block.Header.MerkleTreeRootOfWorldState.ToHex());
response.Header.Height.ShouldBe(block.Height);
response.Header.Time.ShouldBe(block.Header.Time.ToDateTime());
response.Header.ChainId.ShouldBe(ChainHelpers.ConvertChainIdToBase58(chain.Id));
response.Header.Bloom.ShouldBe(block.Header.Bloom.ToByteArray().ToHex());
response.Body.TransactionsCount.ShouldBe(3);
var responseTransactions = response.Body.Transactions;
responseTransactions.Count.ShouldBe(3);
}
// public static List<string> ToPubKeyStrings(this List<ECKeyPair> keyPairs)
// {
// List<string> pubKeyStrings = new List<string>(keyPairs.Count);
//
// foreach (var key in keyPairs)
// pubKeyStrings.Add(key.PublicKey.ToHex());
//
// return pubKeyStrings;
// }
/// <summary>
/// Get random chain Id
/// </summary>
/// <returns></returns>
public static int GetRandomChainId()
{
var random = new Random();
var chainId = ChainHelpers.GetChainId(random.Next(195112, 11316496));
return(chainId);
}
public async Task Withdraw_ChainCreation_ChainNotExist()
{
await InitializeCrossChainContract();
long lockedTokenAmount = 10;
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var tx = await GenerateTransactionAsync(CrossChainContractAddress, nameof(CrossChainContract.RequestChainCreation), null,
sideChainCreationRequest);
await MineAsync(new List <Transaction> {
tx
});
var notExistChainId = ChainHelpers.GetChainId(5);
var txResult =
await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.WithdrawRequest),
new SInt32Value()
{
Value = notExistChainId
});
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
base.ConfigureServices(context);
Configure <CrossChainConfigOption>(option =>
{
option.ParentChainId = ChainHelpers.ConvertBase58ToChainId("AELF");
});
var services = context.Services;
services.AddTransient(o =>
{
var mockService = new Mock <IBlockchainService>();
mockService.Setup(m => m.GetChainAsync())
.Returns(Task.FromResult(new Chain
{
LastIrreversibleBlockHeight = 10
}));
mockService.Setup(m => m.GetBlockHashByHeightAsync(It.IsAny <Chain>(), It.IsAny <long>(), It.IsAny <Hash>()))
.Returns(Task.FromResult(Hash.Generate()));
mockService.Setup(m => m.GetBlockByHashAsync(It.IsAny <Hash>()))
.Returns(Task.FromResult(new Block
{
Height = 10,
Header = new BlockHeader
{
ChainId = 0,
BlockExtraDatas =
{
ByteString.CopyFrom(Hash.Generate().ToByteArray()),
ByteString.CopyFrom(Hash.Generate().ToByteArray())
}
}
}));
return(mockService.Object);
});
services.AddTransient(o =>
{
var mockService = new Mock <ICrossChainExtraDataExtractor>();
mockService.Setup(m => m.ExtractTransactionStatusMerkleTreeRoot(It.IsAny <BlockHeader>()))
.Returns(Hash.Generate);
return(mockService.Object);
});
services.AddTransient(o =>
{
var mockCrossChainDataProvider = new Mock <ICrossChainDataProvider>();
mockCrossChainDataProvider
.Setup(c => c.GetChainInitializationContextAsync(It.IsAny <int>(), It.IsAny <Hash>(), It.IsAny <long>())).Returns(Task.FromResult(new ChainInitializationContext
{
ParentChainHeightOfCreation = 1,
}));
return(mockCrossChainDataProvider.Object);
});
services.AddSingleton <CrossChainRpc.CrossChainRpcBase, CrossChainGrpcServerBase>();
}
public long GetNeededChainHeightForCache(int chainId)
{
var blockInfoCache = _multiChainBlockInfoCacheProvider.GetBlockInfoCache(chainId);
if (blockInfoCache == null)
{
throw new ChainCacheNotFoundException($"Chain {ChainHelpers.ConvertChainIdToBase58(chainId)} cache not found.");
}
return(blockInfoCache.TargetChainHeight());
}
/// <summary>
/// Get information about a given block by block hash. Otionally with the list of its transactions.
/// </summary>
/// <param name="blockHash">block hash</param>
/// <param name="includeTransactions">include transactions or not</param>
/// <returns></returns>
public async Task <BlockDto> GetBlock(string blockHash, bool includeTransactions = false)
{
Hash realBlockHash;
try
{
realBlockHash = Hash.LoadHex(blockHash);
}
catch
{
throw new UserFriendlyException(Error.Message[Error.InvalidBlockHash], Error.InvalidBlockHash.ToString());
}
var block = await GetBlock(realBlockHash);
if (block == null)
{
throw new UserFriendlyException(Error.Message[Error.NotFound], Error.NotFound.ToString());
}
var blockDto = new BlockDto
{
BlockHash = block.GetHash().ToHex(),
Header = new BlockHeaderDto
{
PreviousBlockHash = block.Header.PreviousBlockHash.ToHex(),
MerkleTreeRootOfTransactions = block.Header.MerkleTreeRootOfTransactions.ToHex(),
MerkleTreeRootOfWorldState = block.Header.MerkleTreeRootOfWorldState.ToHex(),
Extra = block.Header.BlockExtraDatas.ToString(),
Height = block.Header.Height,
Time = block.Header.Time.ToDateTime(),
ChainId = ChainHelpers.ConvertChainIdToBase58(block.Header.ChainId),
Bloom = block.Header.Bloom.ToByteArray().ToHex()
},
Body = new BlockBodyDto()
{
TransactionsCount = block.Body.TransactionsCount,
Transactions = new List <string>()
}
};
if (includeTransactions)
{
var transactions = block.Body.Transactions;
var txs = new List <string>();
foreach (var txHash in transactions)
{
txs.Add(txHash.ToHex());
}
blockDto.Body.Transactions = txs;
}
return(blockDto);
}
public Task <JObject> GetChainInformation()
{
var map = SmartContractAddressService.GetSystemContractNameToAddressMapping();
var basicContractZero = SmartContractAddressService.GetZeroSmartContractAddress();
var response = new JObject
{
["GenesisContractAddress"] = basicContractZero?.GetFormatted(),
["ChainId"] = ChainHelpers.ConvertChainIdToBase58(BlockchainService.GetChainId())
};
return(Task.FromResult(response));
}
public async Task Get_Chain_Information_Success()
{
var chainId = _blockchainService.GetChainId();
var basicContractZero = _smartContractAddressService.GetZeroSmartContractAddress();
var response = await JsonCallAsJObject("/chain", "GetChainInformation");
var responseZeroContractAddress = response["result"]["GenesisContractAddress"].ToString();
var responseChainId = ChainHelpers.ConvertBase58ToChainId(response["result"]["ChainId"].ToString());
responseZeroContractAddress.ShouldBe(basicContractZero.GetFormatted());
responseChainId.ShouldBe(chainId);
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
var s = context.Services;
s.TryAddSingleton <ISmartContractAddressNameProvider, ConsensusSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, CrossChainSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, DividendSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, ElectionSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, ParliamentAuthContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, ProfitSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, ResourceSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, ResourceFeeReceiverSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, TokenConverterSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, TokenSmartContractAddressNameProvider>();
s.TryAddSingleton <ISmartContractAddressNameProvider, VoteSmartContractAddressNameProvider>();
var configuration = context.Services.GetConfiguration();
Configure <TokenInitialOptions>(configuration.GetSection("TokenInitial"));
Configure <ChainOptions>(option =>
{
option.ChainId =
ChainHelpers.ConvertBase58ToChainId(context.Services.GetConfiguration()["ChainId"]);
});
Configure <HostSmartContractBridgeContextOptions>(options =>
{
options.ContextVariables[ContextVariableDictionary.NativeSymbolName] = context.Services
.GetConfiguration().GetValue("TokenInitial:Symbol", "ELF");
});
Configure <DPoSOptions>(option =>
{
configuration.GetSection("Consensus").Bind(option);
if (option.InitialMiners == null || option.InitialMiners.Count == 0 ||
string.IsNullOrWhiteSpace(option.InitialMiners[0]))
{
AsyncHelper.RunSync(async() =>
{
var accountService = context.Services.GetRequiredServiceLazy <IAccountService>().Value;
var publicKey = (await accountService.GetPublicKeyAsync()).ToHex();
option.InitialMiners = new List <string> {
publicKey
};
});
}
});
}
protected async Task InitializeCrossChainContract(int parentChainId = 0)
{
var crossChainInitializationTransaction = await Tester.GenerateTransactionAsync(CrossChainContractAddress,
nameof(CrossChainContract.Initialize), new InitializeInput
{
ConsensusContractSystemName = ConsensusSmartContractAddressNameProvider.Name,
TokenContractSystemName = TokenSmartContractAddressNameProvider.Name,
ParentChainId = parentChainId == 0 ? ChainHelpers.ConvertBase58ToChainId("AELF") : parentChainId,
ParliamentContractSystemName = ParliamentAuthContractAddressNameProvider.Name
});
await Tester.MineAsync(new List <Transaction> {
crossChainInitializationTransaction
});
}
public void RequestCrossChainIndexing()
{
//Logger.LogTrace("Request cross chain indexing ..");
var chainIds = _crossChainMemoryCacheService.GetCachedChainIds();
foreach (var chainId in chainIds)
{
if (!_grpcCrossChainClients.TryGetValue(chainId, out var client))
{
continue;
}
Logger.LogTrace($"Request chain {ChainHelpers.ConvertChainIdToBase58(chainId)}");
var targetHeight = _crossChainMemoryCacheService.GetNeededChainHeightForCache(chainId);
var task = TryRequest(client, c => c.StartIndexingRequest(chainId, targetHeight, _crossChainDataProducer));
}
}
/// <summary>
/// Given a block, will generate the next, only the height and
/// the previous will not be random.
/// </summary>
/// <param name="previous">The block to build upon on.</param>
/// <returns>The new block</returns>
public static Block BuildNext(Block previous, string producer = null)
{
Assert.NotNull(previous);
return(new Block
{
Header = new BlockHeader
{
Height = previous.Header.Height + 1,
MerkleTreeRootOfTransactions = Hash.Generate(),
ChainId = ChainHelpers.GetChainId(123),
PreviousBlockHash = previous.GetHash(),
MerkleTreeRootOfWorldState = Hash.Generate(),
Signature = producer == null ? ByteString.Empty : ByteString.CopyFromUtf8(producer)
}
});
}
protected async Task <int> InitAndCreateSideChain(int parentChainId = 0, long lockedTokenAmount = 10)
{
await InitializeCrossChainContract(parentChainId);
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var requestTxResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
await ApproveWithMiners(RequestChainCreationOutput.Parser.ParseFrom(requestTxResult.ReturnValue).ProposalId);
var chainId = ChainHelpers.GetChainId(1);
return(chainId);
}
public async Task GrpcServeNewChainReceivedEventTest()
{
var receivedEventData = new GrpcServeNewChainReceivedEvent
{
LocalChainId = _chainOptions.ChainId,
CrossChainCommunicationContextDto = new GrpcCrossChainCommunicationContext
{
RemoteChainId = ChainHelpers.ConvertBase58ToChainId("ETH"),
RemoteIsSideChain = false,
TargetIp = _grpcCrossChainConfigOption.RemoteParentChainNodeIp,
TargetPort = _grpcCrossChainConfigOption.RemoteParentChainNodePort,
LocalChainId = _chainOptions.ChainId,
LocalListeningPort = _grpcCrossChainConfigOption.LocalServerPort
}
};
await _grpcCrossChainClientNodePlugin.HandleEventAsync(receivedEventData);
}
public async Task Get_SideChain_Height_ChainNotExist()
{
long lockedTokenAmount = 10;
await InitializeCrossChainContract();
await ApproveBalance(lockedTokenAmount);
var chainId = ChainHelpers.GetChainId(1);
var height = await CallContractMethodAsync(CrossChainContractAddress,
nameof(CrossChainContract.GetSideChainHeight),
new SInt32Value()
{
Value = chainId
});
Assert.Equal(ByteString.Empty, height);
}
public async Task Request_SideChain_Disposal_NotFound()
{
await InitializeCrossChainContract();
var txResult =
await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainDisposal),
new SInt32Value()
{
Value = ChainHelpers.GetChainId(5)
});
var status = txResult.Status;
Assert.True(status == TransactionResultStatus.Failed);
Assert.True(txResult.Error.Contains("Side chain not found"));
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
Configure <ChainOptions>(o => { o.ChainId = ChainHelpers.ConvertBase58ToChainId("AELF"); });
var ecKeyPair = CryptoHelpers.GenerateKeyPair();
var nodeAccount = Address.FromPublicKey(ecKeyPair.PublicKey).GetFormatted();
var nodeAccountPassword = "******";
Configure <AccountOptions>(o =>
{
o.NodeAccount = nodeAccount;
o.NodeAccountPassword = nodeAccountPassword;
});
Configure <DPoSOptions>(o =>
{
var miners = new List <string>();
for (var i = 0; i < 3; i++)
{
miners.Add(CryptoHelpers.GenerateKeyPair().PublicKey.ToHex());
}
o.InitialMiners = miners;
o.MiningInterval = 4000;
o.IsBootMiner = true;
});
context.Services.AddTransient <IAccountService>(o =>
{
var mockService = new Mock <IAccountService>();
mockService.Setup(a => a.SignAsync(It.IsAny <byte[]>())).Returns <byte[]>(data =>
Task.FromResult(CryptoHelpers.SignWithPrivateKey(ecKeyPair.PrivateKey, data)));
mockService.Setup(a => a.VerifySignatureAsync(It.IsAny <byte[]>(), It.IsAny <byte[]>(), It.IsAny <byte[]>()
)).Returns <byte[], byte[], byte[]>((signature, data, publicKey) =>
{
var recoverResult = CryptoHelpers.RecoverPublicKey(signature, data, out var recoverPublicKey);
return(Task.FromResult(recoverResult && publicKey.BytesEqual(recoverPublicKey)));
});
mockService.Setup(a => a.GetPublicKeyAsync()).ReturnsAsync(ecKeyPair.PublicKey);
return(mockService.Object);
});
}
public void GetChainId_By_SerialNumber()
{
// Have tested all the conditions (195112UL ~ 11316496UL), To save time, just do some random test
//var base58HashSet = new HashSet<string>();
//var intHashSet = new HashSet<int>();
// for (var i = ; i < 11316496UL; i++)
for (var i = 0; i < 1000; i++)
{
var chainId = 2111;
var base58String = ChainHelpers.ConvertChainIdToBase58(chainId);
base58String.Length.ShouldBe(4);
var newChainId = ChainHelpers.ConvertBase58ToChainId(base58String);
newChainId.ShouldBe(chainId);
// Uncomment this for go through all conditions
// base58HashSet.Add(base58String).ShouldBe(true);
// intHashSet.Add(newChainId).ShouldBe(true);
}
}
public async Task <JObject> GetBlockInfo(long blockHeight, bool includeTransactions = false)
{
var blockInfo = await this.GetBlockAtHeight(blockHeight);
if (blockInfo == null)
{
throw new JsonRpcServiceException(Error.NotFound, Error.Message[Error.NotFound]);
}
// TODO: Create DTO Exntension for Block
var response = new JObject
{
["BlockHash"] = blockInfo.GetHash().ToHex(),
["Header"] = new JObject
{
["PreviousBlockHash"] = blockInfo.Header.PreviousBlockHash.ToHex(),
["MerkleTreeRootOfTransactions"] = blockInfo.Header.MerkleTreeRootOfTransactions.ToHex(),
["MerkleTreeRootOfWorldState"] = blockInfo.Header.MerkleTreeRootOfWorldState.ToHex(),
["Extra"] = blockInfo.Header.BlockExtraDatas.ToString(),
["Height"] = blockInfo.Header.Height.ToString(),
["Time"] = blockInfo.Header.Time.ToDateTime(),
["ChainId"] = ChainHelpers.ConvertChainIdToBase58(blockInfo.Header.ChainId),
["Bloom"] = blockInfo.Header.Bloom.ToByteArray().ToHex()
},
["Body"] = new JObject
{
["TransactionsCount"] = blockInfo.Body.TransactionsCount,
}
};
if (includeTransactions)
{
var transactions = blockInfo.Body.Transactions;
var txs = new List <string>();
foreach (var txHash in transactions)
{
txs.Add(txHash.ToHex());
}
response["Body"]["Transactions"] = JArray.FromObject(txs);
}
return(response);
}
public override SideChainIdAndHeightDict GetSideChainIdAndHeight(Empty input)
{
var dict = new SideChainIdAndHeightDict();
var serialNumber = State.SideChainSerialNumber.Value;
for (long i = 1; i <= serialNumber; i++)
{
int chainId = ChainHelpers.GetChainId(i);
var sideChainInfo = State.SideChainInfos[chainId];
if (sideChainInfo.SideChainStatus != SideChainStatus.Active)
{
continue;
}
var height = State.CurrentSideChainHeight[chainId];
dict.IdHeightDict.Add(chainId, height);
}
return(dict);
}
public async Task Dispose_SideChain()
{
long lockedTokenAmount = 10;
await InitializeCrossChainContract();
await ApproveBalance(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.CopyFromUtf8("Test"));
var requestChainCreationResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainCreation),
sideChainCreationRequest);
await ApproveWithMiners(RequestChainCreationOutput.Parser.ParseFrom(requestChainCreationResult.ReturnValue).ProposalId);
var chainId = ChainHelpers.GetChainId(1);
var requestChainDisposalResult = await ExecuteContractWithMiningAsync(CrossChainContractAddress,
nameof(CrossChainContract.RequestChainDisposal),
new SInt32Value()
{
Value = chainId
});
await ApproveWithMiners(Hash.Parser.ParseFrom(requestChainDisposalResult.ReturnValue));
var chainStatus = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress,
nameof(CrossChainContract.GetChainStatus), new SInt32Value {
Value = chainId
})).Value;
Assert.True(chainStatus == (int)SideChainStatus.Terminated);
var status = SInt32Value.Parser.ParseFrom(await CallContractMethodAsync(CrossChainContractAddress,
nameof(CrossChainContract.GetChainStatus),
new SInt32Value()
{
Value = chainId
})).Value;
Assert.Equal(4, status);
}