public async Task TransactionReadOnlyExecutionServiceExtensions_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
SmartContractAddressService.GetAddressByContractName(TokenSmartContractAddressNameProvider.Name),
"GetBalance", new GetBalanceInput
{
Owner = SampleAddress.AddressList[0],
Symbol = "ELF"
});
var result = await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction,
TimestampHelper.GetUtcNow(),
true);
result.Balance.ShouldBe(0);
result.Symbol.ShouldBe("ELF");
//without such method and call
transaction.MethodName = "NotExist";
await Should.ThrowAsync <SmartContractExecutingException>(async() =>
{
await TransactionReadOnlyExecutionService.ExecuteAsync <GetBalanceOutput>(context, transaction,
TimestampHelper.GetUtcNow(),
true);
});
}
public async Task ParallelExecuteAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
(PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10);
Block = OsTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, PrepareTransactions);
//await BlockExecutingService.ExecuteBlockAsync(Block.Header, PrepareTransactions);
await OsTestHelper.BroadcastTransactions(PrepareTransactions);
Block = await MinerService.MineAsync(chain.BestChainHash, chain.BestChainHeight,
TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromSeconds(4));
await BlockchainService.AddBlockAsync(Block);
await BlockAttachService.AttachBlockAsync(Block);
SystemTransactions = await OsTestHelper.GenerateTransferTransactions(1);
CancellableTransactions = OsTestHelper.GenerateTransactionsWithoutConflict(KeyPairs);
Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height,
SystemTransactions.Concat(CancellableTransactions));
await OsTestHelper.BroadcastTransactions(SystemTransactions.Concat(CancellableTransactions));
var block = await BlockExecutingService.ExecuteBlockAsync(Block.Header,
SystemTransactions, CancellableTransactions, CancellationToken.None);
block.TransactionIds.Count().ShouldBeGreaterThan(10);
}
public async Task RecordSideChainData()
{
var parentChainId = 123;
var lockedToken = 10L;
long parentChainHeightOfCreation = 10;
var sideChainId =
await InitAndCreateSideChainAsync(parentChainHeightOfCreation, parentChainId, lockedToken);
var fakeSideChainBlockHash = Hash.FromString("sideChainBlockHash");
var fakeTxMerkleTreeRoot = Hash.FromString("txMerkleTreeRoot");
var sideChainBlockData =
CreateSideChainBlockData(fakeSideChainBlockHash, 1, sideChainId, fakeTxMerkleTreeRoot);
var crossChainBlockData = new CrossChainBlockData
{
SideChainBlockData = {sideChainBlockData}
};
var indexingTx = await CrossChainContractStub.RecordCrossChainData.SendAsync(crossChainBlockData);
Assert.True(indexingTx.TransactionResult.Status == TransactionResultStatus.Mined);
var balance = await CrossChainContractStub.GetSideChainBalance.CallAsync(new SInt32Value {Value = sideChainId});
Assert.Equal(lockedToken - 1, balance.Value);
var blockHeader = await BlockchainService.GetBestChainLastBlockHeaderAsync();
var indexedCrossChainBlockData =
await CrossChainContractStub.GetIndexedCrossChainBlockDataByHeight.CallAsync(new SInt64Value
{Value = blockHeader.Height});
Assert.Equal(crossChainBlockData, indexedCrossChainBlockData);
}
public async Task <JObject> GetChainStatus()
{
var chain = await BlockchainService.GetChainAsync();
var branches = (JObject)JsonConvert.DeserializeObject(chain.Branches.ToString());
var formattedNotLinkedBlocks = new JArray();
foreach (var notLinkedBlock in chain.NotLinkedBlocks)
{
var block = await this.GetBlock(Hash.LoadBase64(notLinkedBlock.Value));
formattedNotLinkedBlocks.Add(new JObject
{
["BlockHash"] = block.GetHash().ToHex(),
["Height"] = block.Height,
["PreviousBlockHash"] = block.Header.PreviousBlockHash.ToHex()
}
);
}
return(new JObject
{
["Branches"] = branches,
["NotLinkedBlocks"] = formattedNotLinkedBlocks,
["LongestChainHeight"] = chain.LongestChainHeight,
["LongestChainHash"] = chain.LongestChainHash?.ToHex(),
["GenesisBlockHash"] = chain.GenesisBlockHash.ToHex(),
["LastIrreversibleBlockHash"] = chain.LastIrreversibleBlockHash?.ToHex(),
["LastIrreversibleBlockHeight"] = chain.LastIrreversibleBlockHeight,
["BestChainHash"] = chain.BestChainHash?.ToHex(),
["BestChainHeight"] = chain.BestChainHeight
});
}
public AccountController(MySQLContext context, BlockchainService service,
IHostingEnvironment hostingEnvironment)
{
_context = context;
_blockchainService = service;
_hostingEnvironment = hostingEnvironment;
}
public async Task IsViewTransactionAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
await SmartContractAddressService.GetAddressByContractNameAsync(context, TokenSmartContractAddressNameProvider.StringName),
"GetBalance", new GetBalanceInput
{
Owner = SampleAddress.AddressList[0],
Symbol = "ELF"
});
var result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction);
result.ShouldBeTrue();
transaction = OsTestHelper.GenerateTransaction(SampleAddress.AddressList[0],
await SmartContractAddressService.GetAddressByContractNameAsync(context,
TokenSmartContractAddressNameProvider.StringName),
"Transfer", new TransferInput
{
To = SampleAddress.AddressList[1],
Symbol = "ELF",
Amount = 10
});
result = await TransactionReadOnlyExecutionService.IsViewTransactionAsync(context, transaction);
result.ShouldBeFalse();
}
public MedicalController(MySQLContext context, BlockchainService service,
IHostingEnvironment hostingEnvironment)
{
_context = context;
_hostingEnvironment = hostingEnvironment;
_blockchainService = service;
_blockchainService.Initialize();
}
public virtual async Task ChoiceReceivedAsync(IDialogContext context, IAwaitable <string> activity)
{
string response = await activity;
var service = new BlockchainService();
await service.SetRating(Constants.Ratings[response]);
await context.PostAsync("Thank you. Is there anything else I can help you with?");
context.Done(true);
}
public ConnectionHandler(IConnectionManager connectionManager, BlockchainService blockchain, ILogger <ConnectionHandler> logger)
{
Guard.NotNull(connectionManager, nameof(connectionManager));
Guard.NotNull(blockchain, nameof(blockchain));
Guard.NotNull(logger, nameof(logger));
_connectionManager = connectionManager;
_blockchain = blockchain;
_logger = logger;
}
public async Task RecordSideChainData_WithChainNotExist()
{
int parentChainId = 123;
long lockedToken = 10;
long parentChainHeightOfCreation = 10;
var sideChainId1 =
await InitAndCreateSideChainAsync(parentChainHeightOfCreation, parentChainId, lockedToken);
// create second side chain
long lockedTokenAmount = 10;
await ApproveBalanceAsync(lockedTokenAmount);
var sideChainCreationRequest = CreateSideChainCreationRequest(1, lockedTokenAmount, ByteString.Empty);
var sideChainId2 = ChainHelper.GetChainId(2);
await BlockMiningService.MineBlockAsync(new List<Transaction>
{
CrossChainContractStub.CreateSideChain.GetTransaction(sideChainCreationRequest)
}, true);
var fakeSideChainBlockHash = Hash.FromString("sideChainBlockHash");
var fakeTxMerkleTreeRoot = Hash.FromString("txMerkleTreeRoot");
var sideChainBlockData1 =
CreateSideChainBlockData(fakeSideChainBlockHash, 1, sideChainId1, fakeTxMerkleTreeRoot);
var sideChainBlockData2 =
CreateSideChainBlockData(fakeSideChainBlockHash, 2, sideChainId2, fakeTxMerkleTreeRoot);
int fakeChainId = 124;
var sideChainBlockData3 =
CreateSideChainBlockData(fakeSideChainBlockHash, 1, fakeChainId, fakeTxMerkleTreeRoot);
var crossChainBlockData = new CrossChainBlockData
{
SideChainBlockData = {sideChainBlockData1, sideChainBlockData2, sideChainBlockData3}
};
await BlockMiningService.MineBlockAsync(new List<Transaction>
{
CrossChainContractStub.RecordCrossChainData.GetTransaction(crossChainBlockData)
});
var balance = await CrossChainContractStub.GetSideChainBalance.CallAsync(new SInt32Value {Value = sideChainId1});
Assert.Equal(lockedToken - 1, balance.Value);
var blockHeader = await BlockchainService.GetBestChainLastBlockHeaderAsync();
var indexedCrossChainBlockData =
await CrossChainContractStub.GetIndexedCrossChainBlockDataByHeight.CallAsync(new SInt64Value
{Value = blockHeader.Height});
var expectedCrossChainBlocData = new CrossChainBlockData();
expectedCrossChainBlocData.SideChainBlockData.Add(sideChainBlockData1);
Assert.Equal(expectedCrossChainBlocData, indexedCrossChainBlockData);
}
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 BlockchainController(IConfiguration config,
ILogger <BlockchainController> logger,
QueueSender queueSender,
TransactionBroadcastManager transactionBroadcastManager,
BlockchainService blockchainService)
{
this.config = config;
this.logger = logger;
this.queueSender = queueSender;
this.transactionBroadcastManager = transactionBroadcastManager;
this.blockchainService = blockchainService;
}
public BlockchainController(
ILogger <BlockchainController> logger,
ApplicationDbContext context,
BitcoinService bitcoin,
BlockchainService blockchain,
TickerService ticker)
{
_logger = logger;
_context = context;
_bitcoin = bitcoin;
_blockchain = blockchain;
_ticker = ticker;
}
public async Task ExecuteAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
(PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10);
Block = OsTestHelper.GenerateBlock(chain.BestChainHash, chain.BestChainHeight, PrepareTransactions);
PrepareTransactions[0].To = SampleAccount.Accounts[0].Address;
await OsTestHelper.BroadcastTransactions(PrepareTransactions);
var executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto
{
Transactions = PrepareTransactions,
BlockHeader = Block.Header
}, CancellationToken.None);
executionReturnSets.Count.ShouldBe(PrepareTransactions.Count);
executionReturnSets.Count(set => set.TransactionResult.Status == TransactionResultStatus.Failed)
.ShouldBe(1);
executionReturnSets.First(set => set.TransactionResult.Status == TransactionResultStatus.Failed).TransactionResult.Error.ShouldBe("Invalid contract address.");
executionReturnSets.Count(set => set.TransactionResult.Status == TransactionResultStatus.Mined).ShouldBe(9);
(PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10);
Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height, PrepareTransactions);
await OsTestHelper.BroadcastTransactions(PrepareTransactions);
var cancelTokenSource = new CancellationTokenSource();
cancelTokenSource.Cancel();
executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto
{
Transactions = PrepareTransactions,
BlockHeader = Block.Header
}, cancelTokenSource.Token);
executionReturnSets.Count.ShouldBe(0);
(PrepareTransactions, KeyPairs) = await OsTestHelper.PrepareTokenForParallel(10);
Block = OsTestHelper.GenerateBlock(Block.GetHash(), Block.Height, PrepareTransactions);
_systemTransactionExtraDataProvider.SetSystemTransactionCount(1, Block.Header);
executionReturnSets = await _transactionExecutingService.ExecuteAsync(new TransactionExecutingDto
{
Transactions = PrepareTransactions,
BlockHeader = Block.Header
}, CancellationToken.None);
executionReturnSets.Count.ShouldBe(PrepareTransactions.Count);
executionReturnSets.ShouldAllBe(set => set.TransactionResult.Status == TransactionResultStatus.Mined);
}
public async Task GetFileDescriptorsAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var tokenAddress =
SmartContractAddressService.GetAddressByContractName(TokenSmartContractAddressNameProvider.Name);
var fileDescriptor =
(await TransactionReadOnlyExecutionService.GetFileDescriptorsAsync(context, tokenAddress)).ToList();
fileDescriptor.Count.ShouldBeGreaterThan(0);
fileDescriptor.ShouldAllBe(o => o.Name.Contains("proto"));
}
public async Task HandleEventAsync(BlockMinedEventData eventData)
{
if (eventData?.BlockHeader == null)
{
Logger.LogWarning("Block header is null, cannot broadcast.");
return;
}
var blockWithTransactions = await BlockchainService.GetBlockWithTransactionsByHash(eventData.BlockHeader.GetHash());
if (blockWithTransactions == null)
{
Logger.LogWarning($"Could not find {eventData.BlockHeader.GetHash()}.");
return;
}
var _ = NetworkService.BroadcastBlockWithTransactionsAsync(blockWithTransactions);
}
public async Task TokenFeeProviderBase_Calculate_Test()
{
var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>());
var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>());
var blockStateSet = new BlockStateSet
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet);
var functionMap = GenerateFunctionMap();
await _calculateFunctionProvider.AddCalculateFunctions(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
},
functionMap);
var transaction = new Transaction
{
Params = new SInt64Value
{
Value = 100
}.ToByteString()
};
var transactionContext = new TransactionContext
{
Transaction = transaction
};
var size = transaction.Size();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var sizeFee = await _primaryTokenFeeProvider.CalculateFeeAsync(transactionContext, chainContext);
var feeCalculatedByCoefficients = GetFeeForTx(size);
sizeFee.ShouldBe(feeCalculatedByCoefficients);
}
public async Task CalculateFunctionMap_Test()
{
var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>());
var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>());
var blockStateSet = new BlockStateSet
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet);
var functionMapDict = new Dictionary <string, Dictionary <string, CalculateFunction> >();
var functionMap = GenerateFunctionMap();
functionMapDict.Add(GetBlockExecutedDataKey(), functionMap);
await _calculateFunctionExecutedDataService.AddBlockExecutedDataAsync(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
},
functionMapDict);
var newBlockStateSet = await BlockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash);
newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight);
newBlockStateSet.BlockExecutedData.Count.ShouldBe(1);
newBlockStateSet.BlockExecutedData.Keys.ShouldContain(key =>
key.Contains(typeof(AllCalculateFeeCoefficients).Name));
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, functionMap);
await BlockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
CheckBlockExecutedData(blockStateSet, functionMap);
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, functionMap);
}
public async Task GetTransactionParametersAsync_Test()
{
var chain = await BlockchainService.GetChainAsync();
var context = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = await OsTestHelper.GenerateTransferTransaction();
var jsonResult =
await TransactionReadOnlyExecutionService.GetTransactionParametersAsync(context, transaction);
jsonResult.ShouldNotBeEmpty();
jsonResult.ShouldContain("to");
jsonResult.ShouldContain("symbol");
jsonResult.ShouldContain("amount");
}
public async Task MineWithTxHubAsync()
{
var txCount = 0;
var preBlockHash = _chain.BestChainHash;
var preBlockHeight = _chain.BestChainHeight;
while (txCount < TransactionCount)
{
var blockExecutedSet = await _minerService.MineAsync(preBlockHash, preBlockHeight,
TimestampHelper.GetUtcNow(), TimestampHelper.DurationFromMilliseconds(4000));
txCount += blockExecutedSet.TransactionIds.Count();
_transactionIdList.AddRange(blockExecutedSet.TransactionIds.ToList());
await BlockchainService.SetBestChainAsync(_chain, preBlockHeight, preBlockHash);
await TransactionPoolService.CleanByTransactionIdsAsync(blockExecutedSet.TransactionIds);
await TransactionPoolService.UpdateTransactionPoolByBestChainAsync(preBlockHash, preBlockHeight);
}
}
public async Task CalculateFunctionMap_Test()
{
var genesisBlock = KernelTestHelper.GenerateBlock(0, Hash.Empty, new List <Transaction>());
var chain = await BlockchainService.CreateChainAsync(genesisBlock, new List <Transaction>());
var blockStateSet = new BlockStateSet
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
await BlockStateSetManger.SetBlockStateSetAsync(blockStateSet);
var blockExecutedDataKey = "BlockExecutedData/AllCalculateFeeCoefficients";
blockStateSet.BlockExecutedData.ShouldNotContainKey(blockExecutedDataKey);
var functionMap = GenerateFunctionMap();
await _calculateFunctionProvider.AddCalculateFunctions(new BlockIndex
{
BlockHash = blockStateSet.BlockHash,
BlockHeight = blockStateSet.BlockHeight
},
functionMap);
var newBlockStateSet = await BlockStateSetManger.GetBlockStateSetAsync(chain.BestChainHash);
newBlockStateSet.BlockHash.ShouldBe(blockStateSet.BlockHash);
newBlockStateSet.BlockHeight.ShouldBe(blockStateSet.BlockHeight);
newBlockStateSet.BlockExecutedData.Count.ShouldBe(1);
newBlockStateSet.BlockExecutedData.ShouldContainKey(blockExecutedDataKey);
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, functionMap);
await BlockchainStateService.MergeBlockStateAsync(chain.BestChainHeight, chain.BestChainHash);
CheckBlockExecutedData(blockStateSet, functionMap);
blockStateSet = await AddBlockStateSetAsync(blockStateSet);
CheckBlockExecutedData(blockStateSet, functionMap);
}
protected override void OnStart(string[] args)
{
Task.Factory.StartNew(() =>
{
while (!_isStopped)
{
using (var localAccountService = new AccountService())
{
if (!localAccountService.UpdateData())
{
Thread.Sleep(1000 * 60 * 1);
}
else
{
Thread.Sleep(1000 * 60 * 10);
}
}
}
});
Task.Factory.StartNew(() =>
{
while (!_isStopped)
{
using (var localAccountService = new AccountService())
{
var localBlockchainService = new BlockchainService(localAccountService);
if (!localBlockchainService.UpdateData())
{
Thread.Sleep(1000 * 60 / 6);
}
else
{
Thread.Sleep(1000 * 60);
}
}
}
});
}
private async Task <ItemData> GetItemData(string id)
{
var service = new BlockchainService();
return(await service.GetItemData(id));
}
internal async Task <Hash> AEDPoSContract_GetRandomNumber_Test()
{
var order = await AEDPoSContract_RequestRandomNumber_Test();
var currentRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty());
var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount)
.Select(i => Hash.FromString($"random{i}")).ToList();
var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i =>
new AElfConsensusTriggerInformation
{
Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey),
RandomHash = randomHashes[i]
}).ToDictionary(t => t.Pubkey.ToHex(), t => t);
// Exactly one round except extra block time slot.
foreach (var minerInRound in currentRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order))
{
var currentKeyPair =
InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey);
KeyPairProvider.SetKeyPair(currentKeyPair);
BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime);
var stub = GetAEDPoSContractStub(currentKeyPair);
var headerInformation =
(await stub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey]
.ToBytesValue())).ToConsensusHeaderInformation();
// Update consensus information.
var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey);
await stub.UpdateValue.SendAsync(toUpdate);
{
var chain = await BlockchainService.GetChainAsync();
if (chain.BestChainHeight < order.BlockHeight)
{
// Not enough.
var transactionResult = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash))
.TransactionResult;
transactionResult.Error.ShouldContain("Still preparing random number.");
}
}
for (var i = 0; i < 7; i++)
{
await stub.UpdateTinyBlockInformation.SendAsync(new TinyBlockInput
{
ActualMiningTime = TimestampHelper.GetUtcNow(),
RoundId = currentRound.RoundId
});
}
}
// Now it's enough.
{
var randomNumber = (await AEDPoSContractStub.GetRandomNumber.SendAsync(order.TokenHash)).Output;
randomNumber.Value.ShouldNotBeEmpty();
}
return(order.TokenHash);
}
public DonateController(BlockchainService blockchainService)
{
_blockchainService = blockchainService;
}
public BlockchainProposalsController(BlockchainService blockchainService)
{
this.BlockchainService = blockchainService ?? throw new ArgumentNullException(nameof(blockchainService));
}
public async Task GlobalSetup()
{
await InitializeChainAsync();
_chain = await BlockchainService.GetChainAsync();
}
public DisbandForm(int myTeammateId)
{
_accountService = new AccountService();
_me = _accountService.GetTeammate(myTeammateId);
_curAddress = _me.BtcAddressCurrent;
_prevAddress = _me.BtcAddressPrevious;
_user = _accountService.GetUser();
InitializeComponent();
_textBoxAuxAddress.Text = _accountService.GetAuxWallet(_me.Team.Network).ToString();
_textBoxAddressTo.Text = _me.CurDisbanding.WithdrawAddr;
UpdateStatuses();
UpdateWithdrawalControls();
UpdateCosignerOfControls();
Task.Factory.StartNew(() =>
{
if (!_accountService.Closed) // todo: change it to separate contexts
{
var blockchainService = new BlockchainService(_accountService);
blockchainService.TryFetchAuxWalletUtxos(true, _me.Team.Network);
if (!_closing)
{
try
{
this.Invoke((MethodInvoker) delegate()
{
UpdateStatuses();
});
}
catch (Exception ex) {
Logger.WriteException(ex);
}
}
}
});
Task.Factory.StartNew(() =>
{
if (!_accountService.Closed) // todo: change it to separate contexts
{
var blockchainService = new BlockchainService(_accountService);
if (_curAddress != null)
{
_amountSatoshisCurent = blockchainService.FetchBalance(_curAddress);
}
if (_prevAddress != null)
{
_amountSatoshisPrevious = blockchainService.FetchBalance(_prevAddress);
}
if (!_closing)
{
try
{
this.Invoke((MethodInvoker) delegate()
{
UpdateWithdrawalControls();
});
}
catch (Exception ex) {
Logger.WriteException(ex);
}
}
}
});
}
public HomeController(BlockchainService service)
{
_blockchainService = service;
_blockchainService.Initialize();
}
public SmartContractController(MySQLContext context, BlockchainService service)
{
_context = context;
_blockchainService = service;
}
