private async Task InsertOrUpdateDappInfoAsync(NpgsqlConnection connection, RootObject root, CancellationToken token)
{
var info = root.Data.Info;
var dApp = new Dapp
{
Id = info.Id,
Author = info.Author,
Slug = info.Slug,
Description = info.Description,
Title = info.Title,
Url = info.Url,
Category = info.Category
};
var contracts = new ulong[root.Data.Contracts.Count];
for (var i = 0; i < root.Data.Contracts.Count; i++)
{
var contract = root.Data.Contracts[i];
var aId = BaseName.StringToName(contract.Address);
var a = BaseName.UlongToString(aId);
if (a.Equals(contract.Address, StringComparison.Ordinal))
{
contracts[i] = aId;
}
else
{
return;
}
}
await connection.InsertOrUpdateAsync(dApp, contracts, token);
}
public void TestCreateNewBlock()
{
var dapp = new Dapp
{
Name = "Dapp1",
Description = "Dapp1 Test",
Git = "[email protected]:LiskHQ/LiskSDK.git",
Category = 0,
Type = 0,
Link = "[email protected]:Rajbandi/DappTest.git"
};
var block = BlockHelper.CreateNewBlock(_genesisAccount, dapp);
Debug.WriteLine(block);
}
public static string ValidateDapp(Dapp dapp)
{
var error = string.Empty;
if (string.IsNullOrWhiteSpace(dapp.Name))
{
error = "DApp name is too short, minimum is 1 character";
}
else if (dapp.Name.Length > 32)
{
error = "DApp name is too long, maximum is 32 characters";
}
else
if (!string.IsNullOrWhiteSpace(dapp.Description) && dapp.Description.Length > 160)
{
error = "DApp description is too long, maximum is 160 characters";
}
return(error);
}
private async Task InsertOrUpdateDappInfoAsync(NpgsqlConnection connection, RootObject root, CancellationToken token)
{
const int minId = 1000000;
const int maxId = 3000000;
var dapp = new Dapp
{
Author = root.app.developer ?? string.Empty,
Slug = root.app.identifier,
Description = root.app.desc_en ?? string.Empty,
Title = root.app.@abstract ?? string.Empty,
Url = root.app.url ?? string.Empty,
Category = root.app.category?.name ?? string.Empty
};
var contracts = new ulong[root.app.contracts.Length];
for (var i = 0; i < root.app.contracts.Length; i++)
{
var contract = root.app.contracts[i];
var name = contract.Type == JTokenType.String
? contract.Value <string>()
: contract.Value <string>("address");
var aId = BaseName.StringToName(name);
var a = BaseName.UlongToString(aId);
if (a.Equals(name, StringComparison.Ordinal))
{
contracts[i] = aId;
}
else
{
return;
}
}
await connection.FindAndInsertOrUpdateAsync(minId, maxId, dapp, contracts, token);
}
public static Block CreateNewBlock(Account genesisAccount, Dapp dapp)
{
var transactions = new List <Transaction>();
var delegates = new List <Account>();
var sender = AccountHelper.GetAccount(CryptoHelper.GenerateSecret());
long totalAmount = 0;
var balTransaction = new Transaction
{
Type = TransactionType.Send,
Amount = 10000000000000000,
Fee = 0,
Timestamp = 0,
RecipientId = genesisAccount.Address.IdString,
SenderId = sender.Address.IdString,
SenderPublicKey = sender.Address.KeyPair.PublicKey.ToHex()
};
totalAmount += balTransaction.Amount;
var bytes = balTransaction.GetBytes();
balTransaction.Signature = CryptoHelper.Sign(bytes, sender.Address.KeyPair.PrivateKey).ToHex();
balTransaction.Id = CryptoHelper.GetId(sender.Address.KeyPair.PublicKey);
transactions.Add(balTransaction);
for (int index = 0; index < Constants.ActiveDelegates; index++)
{
var delegateSecret = CryptoHelper.GenerateSecret();
var delAccount = AccountHelper.GetAccount(delegateSecret);
delegates.Add(delAccount);
var userName = string.Format("genesisDelegate{0}", index + 1);
var delTransaction = new Transaction
{
Type = TransactionType.Delegate,
Amount = 0,
Fee = 0,
Timestamp = 0,
RecipientId = null,
SenderId = delAccount.Address.IdString,
SenderPublicKey = delAccount.Address.KeyPair.PublicKey.ToHex(),
Asset = new DelegateUsernameAsset
{
Delegate = new DelegateUsername
{
Username = userName
}
}
};
var delBytes = delTransaction.GetBytes();
delTransaction.Signature = CryptoHelper.Sign(delBytes, delAccount.Address.KeyPair.PrivateKey).ToHex();
delTransaction.Id = CryptoHelper.GetId(delBytes);
transactions.Add(delTransaction);
}
var votes = delegates.Select(vote => string.Format("+{0}", vote.Address.KeyPair.PublicKey.ToHex()));
var voteAsset = new DelegateVoteAsset();
voteAsset.Votes.AddRange(votes);
var voteTransaction = new Transaction
{
Type = TransactionType.Vote,
Amount = 0,
Fee = 0,
Timestamp = 0,
RecipientId = genesisAccount.Address.IdString,
SenderId = genesisAccount.Address.IdString,
SenderPublicKey = genesisAccount.Address.KeyPair.PublicKey.ToHex(),
Asset = voteAsset
};
var voteBytes = voteTransaction.GetBytes();
voteTransaction.Signature = CryptoHelper.Sign(voteBytes, genesisAccount.Address.KeyPair.PrivateKey).ToHex();
voteTransaction.Id = CryptoHelper.GetId(voteBytes);
transactions.Add(voteTransaction);
var dappTransaction = new Transaction
{
Type = TransactionType.Dapp,
Amount = 0,
Fee = 0,
Timestamp = 0,
RecipientId = null,
SenderId = genesisAccount.Address.IdString,
SenderPublicKey = genesisAccount.Address.KeyPair.PublicKey.ToHex(),
Asset = new DappAsset
{
Dapp = dapp
}
};
var dappBytes = dappTransaction.GetBytes();
dappTransaction.Signature = CryptoHelper.Sign(dappBytes, genesisAccount.Address.KeyPair.PrivateKey).ToHex();
dappTransaction.Id = CryptoHelper.GetId(dappBytes);
transactions.Add(dappTransaction);
var sortedTransactions = transactions.OrderBy(t => (int)t.Type).ThenBy(t => t.Amount).ToList();
var payloadLength = 0;
var hashBuf = new List <byte>();
foreach (var sortedTransaction in sortedTransactions)
{
var trBytes = sortedTransaction.GetBytes();
payloadLength += trBytes.Length;
hashBuf.AddRange(trBytes);
}
var payloadHash = CryptoHelper.Sha256(hashBuf.ToArray());
var block = new Block
{
Version = 0,
TotalAmount = 0,
TotalFee = 0,
PayloadHash = payloadHash.ToHex(),
Timestamp = 0,
NumberOfTransactions = sortedTransactions.Count,
PayloadLength = payloadLength,
PreviousBlock = null,
GeneratorPublicKey = sender.Address.KeyPair.PublicKey.ToHex(),
Transactions = sortedTransactions,
Height = 1
};
var blockBytes = block.GetBytes();
block.BlockSignature = CryptoHelper.Sign(blockBytes, sender.Address.KeyPair.PrivateKey).ToHex();
block.Id = CryptoHelper.GetId(blockBytes).ToString();
return(block);
}
public static DappTransactionBlock CreateFromBlock(Block genesisBlock, Account genesisAccount, Dapp dapp)
{
var sender = AccountHelper.GetAccount(CryptoHelper.GenerateSecret());
foreach (var transaction in genesisBlock.Transactions)
{
if (transaction.Type == TransactionType.Dapp)
{
var asset = (DappAsset)transaction.Asset;
if (asset != null)
{
if (asset.Dapp.Name == dapp.Name)
{
throw new DappException(string.Format("Dapp with name {0} already exist", dapp.Name));
}
if (asset.Dapp.Git == dapp.Git)
{
throw new DappException(string.Format("Dapp with git {0} already exist", dapp.Git));
}
if (asset.Dapp.Link == dapp.Link)
{
throw new DappException(string.Format("Dapp with link {0} already exist", dapp.Link));
}
}
}
}
var dappTransaction = new Transaction
{
Type = TransactionType.Dapp,
Amount = 0,
Fee = 0,
Timestamp = 0,
RecipientId = null,
SenderId = genesisAccount.Address.IdString,
SenderPublicKey = genesisAccount.Address.KeyPair.PublicKey.ToHex(),
Asset = new DappAsset
{
Dapp = dapp
}
};
var dappBytes = dappTransaction.GetBytes();
dappTransaction.Signature = CryptoHelper.Sign(dappBytes, genesisAccount.Address.KeyPair.PrivateKey).ToHex();
dappTransaction.Id = CryptoHelper.GetId(dappBytes);
genesisBlock.PayloadLength += dappBytes.Length;
var payloadBytes = genesisBlock.PayloadHash.FromHex();
var trBytes = new byte[payloadBytes.Length + dappBytes.Length];
Buffer.BlockCopy(payloadBytes, 0, trBytes, 0, payloadBytes.Length);
Buffer.BlockCopy(dappBytes, payloadBytes.Length, trBytes, 0, dappBytes.Length);
var trHash = CryptoHelper.Sha256(trBytes);
genesisBlock.Transactions.Add(dappTransaction);
genesisBlock.NumberOfTransactions++;
genesisBlock.GeneratorPublicKey = sender.Address.KeyPair.PublicKey.ToHex();
var blockBytes = genesisBlock.GetBytes();
genesisBlock.BlockSignature = CryptoHelper.Sign(blockBytes, sender.Address.KeyPair.PublicKey).ToHex();
genesisBlock.Id = CryptoHelper.GetId(blockBytes).ToString();
return(new DappTransactionBlock
{
Block = genesisBlock,
Dapp = dappTransaction
});
}
public static async Task InsertOrUpdateAsync(this NpgsqlConnection connection, Dapp dApp, ulong[] contracts, CancellationToken token)
{
var cmd = @"INSERT INTO public.dapp(id, author, slug, description, title, url, category) VALUES (@p1, @p2, @p3, @p4, @p5, @p6, @p7)
ON CONFLICT ON CONSTRAINT pk_dapp DO UPDATE SET (author, slug, description, title, url, category) = (@p2, @p3, @p4, @p5, @p6, @p7);";
var command = new NpgsqlCommand
{
Connection = connection,
CommandText = cmd
};
command.Parameters.AddValue("@p1", dApp.Id);
command.Parameters.AddValue("@p2", dApp.Author);
command.Parameters.AddValue("@p3", dApp.Slug);
command.Parameters.AddValue("@p4", dApp.Description);
command.Parameters.AddValue("@p5", dApp.Title);
command.Parameters.AddValue("@p6", dApp.Url);
command.Parameters.AddValue("@p7", dApp.Category);
await command.ExecuteNonQueryAsync(token);
await connection.ReInsertDappContractAsync(dApp.Id, contracts, token);
}
public static async Task FindAndInsertOrUpdateAsync(this NpgsqlConnection connection, int minId, int maxId, Dapp dapp, ulong[] contracts, CancellationToken token)
{
var ids = await connection.SelectDappIdByKeyAsync(dapp.Slug, token);
var id = ids.FirstOrDefault(i => i > minId && i < maxId);
if (id == 0)
{
id = ids.FirstOrDefault(i => i < minId);
if (id == 0)
{
id = await connection.SelectMaxDappIdInRangeAsync(minId + minId, maxId, token);
if (id == 0)
{
id = minId + minId;
}
id++;
}
else
{
id += minId;
}
}
dapp.Id = id;
await connection.InsertOrUpdateAsync(dapp, contracts, token);
}
