public static FastZipPackage Open(string originalFilePath, IHashProvider hashProvider)
{
var result = new FastZipPackage(originalFilePath);
using (var package = Package.Open(originalFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var packageRelationship = package.GetRelationshipsByType("http://schemas.microsoft.com/packaging/2010/07/manifest").SingleOrDefault();
if (packageRelationship == null)
throw new InvalidOperationException("Package does not contain a manifest");
var part = package.GetPart(packageRelationship.TargetUri);
using (var stream2 = part.GetStream())
result.ReadManifest(stream2);
}
using (var stream = new FileStream(originalFilePath, FileMode.Open, FileAccess.Read))
{
result.Hash = hashProvider.CalculateHash(stream);
}
var info = new FileInfo(originalFilePath);
result.Created = info.CreationTimeUtc;
result.Size = info.Length;
return result;
}
public static string GetHash(this IPackage package, IHashProvider hashProvider)
{
using (Stream stream = package.GetStream())
{
return Convert.ToBase64String(hashProvider.CalculateHash(stream));
}
}
public static string GetHash(this IPackage package, IHashProvider hashProvider)
{
using (Stream stream = package.GetStream()) {
byte[] packageBytes = stream.ReadAllBytes();
return Convert.ToBase64String(hashProvider.CalculateHash(packageBytes));
}
}
public static string GetHash(this IPackage package, IHashProvider hashProvider)
{
using (Stream stream = package.GetStream()) {
byte[] packageBytes = stream.ReadAllBytes();
return(Convert.ToBase64String(hashProvider.CalculateHash(packageBytes)));
}
}
public static IFastZipPackage Open(string fileLocation, IHashProvider hashProvider)
{
using (var stream = new FileStream(fileLocation, FileMode.Open, FileAccess.Read))
{
var hash = hashProvider.CalculateHash(stream);
stream.Seek(0, SeekOrigin.Begin);
return Open(fileLocation, stream, hash);
}
}
public static IFastZipPackage Open(string fileLocation, IHashProvider hashProvider)
{
using (var stream = new FileStream(fileLocation, FileMode.Open, FileAccess.Read))
{
var hash = hashProvider.CalculateHash(stream);
stream.Seek(0, SeekOrigin.Begin);
return(Open(fileLocation, stream, hash));
}
}
public IActionResult Transactions(string userName)
{
var hashedUserName = _hash.CalculateHash(userName);
var transactions = _db.Transactions
.Where(x => x.FromAddress == userName || x.FromAddress == hashedUserName)
.ToList();
var totalDonated = transactions.Where(x => x.IsDonated).Sum(x => x.Amount);
var totalUnDonated = transactions.Where(x => !x.IsDonated).Sum(x => x.Amount);
return(Json(new { totalDonated, totalUnDonated, transactions }));
}
private DerivedPackageData CalculateDerivedData(IPackage package, string path)
{
byte[] hashBytes;
long fileLength;
using (Stream stream = FileSystem.OpenFile(path))
{
fileLength = stream.Length;
hashBytes = HashProvider.CalculateHash(stream);
}
return(new DerivedPackageData
{
PackageSize = fileLength,
PackageHash = Convert.ToBase64String(hashBytes),
LastUpdated = FileSystem.GetLastModified(path),
Created = FileSystem.GetCreated(path),
// TODO: Add support when we can make this faster
// SupportedFrameworks = package.GetSupportedFrameworks(),
Path = path,
FullPath = FileSystem.GetFullPath(path)
});
}
public static async Task Validate(Transaction transaction)
{
var transactionStrings = JsonConvert.SerializeObject(transaction, Formatting.Indented);
Console.WriteLine($"New Transaction : {transactionStrings} \n");
float moneyLeft = 999999999.00f;
User fromUser = new User();
if (!IsDonatable)
{
fromUser = _dbContext.Users.FirstOrDefault(x => x.Username == transaction.FromAddress);
moneyLeft = fromUser.RemainingMoney;
}
if (moneyLeft < transaction.Amount)
{
Console.WriteLine("Money Not Enough!");
}
else
{
if (!IsDonatable)
{
Console.WriteLine("User's Money : " + JsonConvert.SerializeObject(fromUser));
fromUser.RemainingMoney -= transaction.Amount;
}
transaction.HashedTransactionId = _hash.HashTransaction(transaction);
var serializedTransaction = JsonConvert.SerializeObject(transaction);
Client.Broadcast($"Verify : {serializedTransaction}");
while (ConfirmedNumber < RequiredNumber() && ConfirmedNumber + RejectedNumber < NumNode)
{
await Task.Delay(1000);
}
if (ConfirmedNumber < RequiredNumber())
{
Console.WriteLine("Rejected Transaction.....");
ConfirmedNumber = 1;
RejectedNumber = 0;
}
else
{
var blockCharName = _dbContext.Foundations.OrderBy(x => x.NameEn).LastOrDefault()?.NameEn;
if (transaction.ToAddress == blockCharName)
{
var foundations = _dbContext.Foundations.FirstOrDefault(x => x.NameEn == transaction.ToAddress);
var donatedTransactions = _dbContext.Transactions
.Where(x => x.IntendedFoundation == blockCharName)
.ToList();
foundations.TotalDonate += foundations.TotalUnDonate;
foundations.TotalUnDonate = 0;
donatedTransactions.ForEach(x => x.IsDonated = true);
transaction.IsDonated = true;
}
else
{
var foundations = _dbContext.Foundations.FirstOrDefault(x => x.NameEn == transaction.IntendedFoundation);
foundations.TotalUnDonate += transaction.Amount;
transaction.FromAddress = _hash.CalculateHash(transaction.FromAddress);
}
// foundations.TotalDonate += transaction.Amount;
_dbContext.Transactions.Add(transaction);
_dbContext.SaveChanges();
ConfirmedNumber = 1;
RejectedNumber = 0;
Console.WriteLine("Added Transaction.....");
await Task.Delay(5000);
BlockGeneric block;
BlockGeneric prevBlock;
if (Program.Port == 2222)
{
block = new Block1();
prevBlock = _dbContext.Blockchains1
.OrderBy(x => x.UnixTimeStamp)
.LastOrDefault();
}
else if (Program.Port == 2223)
{
block = new Block2();
prevBlock = _dbContext.Blockchains2
.OrderBy(x => x.UnixTimeStamp)
.LastOrDefault();
}
else
{
block = new Block3();
prevBlock = _dbContext.Blockchains3
.OrderBy(x => x.UnixTimeStamp)
.LastOrDefault();
}
var transactions = _dbContext.Transactions
.Where(x => !x.IsCommitted)
.OrderBy(x => x.UnixTimeStamp)
.Take(block.MaxBlockSize)
.ToList();
var hashedTransactions = String.Join('-', transactions.Select(x => x.HashedTransactionId));
block.HashedTransactionIds = hashedTransactions;
block.Height = (prevBlock?.Height + 1) ?? 0;
block.PreviousHash = prevBlock?.Hash;
block.TransactionJsons = transactions != null?JsonConvert.SerializeObject(transactions) : null;
block.UnixTimeStamp = DateTime.Now.ToUnixTimeStamp();
block.Hash = _hash.HashBlock(block);
block.VerifiedBy = _hash.CalculateHash(Program.Port.ToString());
block.BlockSize = transactions.Count;
transactions.ForEach(x => x.BlockHeight = block.Height);
var serializedBlock = JsonConvert.SerializeObject(block, Formatting.Indented);
Console.WriteLine($"Transaction inside \n {JsonConvert.SerializeObject(transactions, Formatting.Indented)}");
Console.WriteLine($"BlockSize : {block.BlockSize}");
Console.WriteLine($"Block : {serializedBlock}\n");
Client.Broadcast($"New Block : {serializedBlock}");
while (ConfirmedNumber < RequiredNumber() && ConfirmedNumber + RejectedNumber < NumNode)
{
await Task.Delay(30);
}
if (ConfirmedNumber < RequiredNumber())
{
Console.WriteLine("Rejected Block.....");
}
else
{
Console.WriteLine("Added Block.....");
transactions.ForEach(x => x.IsCommitted = true);
if (Program.Port == 2222)
{
_dbContext.Blockchains1.Add((Block1)block);
}
else if (Program.Port == 2223)
{
_dbContext.Blockchains2.Add((Block2)block);
}
else
{
_dbContext.Blockchains3.Add((Block3)block);
}
await _dbContext.SaveChangesAsync();
Client.Broadcast($"Add Block to Chain : {JsonConvert.SerializeObject(block)}");
PreDonateToFoundationIfAble(transaction);
}
ConfirmedNumber = 1;
RejectedNumber = 0;
}
}
}
private static string GetHash(this Stream stream, IHashProvider hashProvider)
{
return(Convert.ToBase64String(hashProvider.CalculateHash(stream)));
}
private static string GetHash(this string input, IHashProvider hashProvider)
{
return(Convert.ToBase64String(hashProvider.CalculateHash(Encoding.UTF8.GetBytes(input))));
}
