public void HexToBufferConvertTest(int count)
{
var expectedBuffer = new byte[count];
new Random(count).NextBytes(expectedBuffer);
var expectedHexString = BitConverter.ToString(expectedBuffer).Replace("-", "").ToLowerInvariant();
var expectedHexBuffer = expectedHexString.ToCharArray();
// hex string -> buffer
var buffer = HexConvert.ToBytes(expectedHexString, 0, expectedHexString.Length);
Assert.Equal(expectedBuffer, buffer);
// hex buffer -> buffer
buffer = HexConvert.ToBytes(expectedHexBuffer, 0, expectedHexBuffer.Length);
Assert.Equal(expectedBuffer, buffer);
// hex buffer -> buffer (copy)
buffer = new byte[expectedBuffer.Length];
HexConvert.Decode(new ArraySegment <char>(expectedHexBuffer, 0, expectedHexBuffer.Length), new ArraySegment <byte>(buffer));
Assert.Equal(expectedBuffer, buffer);
// hex buffer -> buffer (copy)
buffer = new byte[expectedBuffer.Length];
HexConvert.Decode(expectedHexString, 0, expectedHexBuffer.Length, new ArraySegment <byte>(buffer));
Assert.Equal(expectedBuffer, buffer);
}
public static void WriteDataCoinPocket(CoinPocket pocket)
{
Console.WriteLine("______Welcome to wallet!______\n");
Console.WriteLine("Your wallet is: {0}",
HexConvert.FromBytes(pocket.KeyPair.PublicKey));
Console.WriteLine("On your account: {0} ACT", pocket.Amount);
}
public WindowPersonalArea(CoinPocket user)
{
InitializeComponent();
_userCoinPocket = user;
GroupBoxInformationAboutUser.Header = user.UserName;
TextBlockId.Text = HexConvert.FromBytes(user.KeyPair.PublicKey);
var blockchain = DataManager.UploadBlockchainDictionary();
/* var amount = int.Parse(Executor
* .GetCash(DataManager.UploadBlockchainDictionary(), user.KeyPair.PublicKey).ToString());*/
var amount = int.Parse(Executor
.GetCashRec(blockchain, user.KeyPair.PublicKey, blockchain.Last().Key).ToString());
Amount = amount;
if (amount > -1)
{
TextBlockAct.Text = amount + " @";
}
else
{
TextBlockAct.Text = "Fail parse blockchain.";
}
TextBoxRecipientId.Text = "";
TextBoxAmountAct.Text = "";
}
public void ConvertEmptyArrayShouldBeEmptyString()
{
var bytes = new byte [0];
var result = HexConvert.ToString(bytes);
Assert.AreEqual(0, result.Length);
}
public void TestInvalidConversion()
{
Assert.Throws <ArgumentException>(() => {
const string invalidHash = "blahb";
HexConvert.FromString(invalidHash);
});
}
public static void Save(string path, StringBuilder s)
{
byte[] buffer = HexConvert.HexStringToByteArray(s.ToString());
using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write))
{
fs.Write(buffer, 0, buffer.Length);
}
}
public void ConvertFFShouldBeFF()
{
var bytes = new byte [] { 0xff };
var result = HexConvert.ToString(bytes);
Assert.AreEqual(2, result.Length);
Assert.AreEqual("ff", result);
}
public void ConvertOneByteShouldBeTwoCharacters()
{
var bytes = new byte [] { 0x01 };
var result = HexConvert.ToString(bytes);
Assert.AreEqual(2, result.Length);
Assert.AreEqual("01", result);
}
public void TestConversion()
{
const string originalHash = "012eab4c54886ca3fa52039afe03dcdf";
var byteHash = HexConvert.FromString(originalHash);
var convertedHash = HexConvert.ToString(byteHash);
Assert.AreEqual(originalHash, convertedHash);
}
public void ToCharArrayTest()
{
var expected = "9c".ToCharArray();
var data = new byte[] { 156 };
var actual = HexConvert.ToCharArray(data, lowerCase: true);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayPartialTest()
{
var baseNCharBytes = "999c99".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNCharBytes, 2, baseNCharBytes.Length - 4);
Assert.Equal(expected, actual);
}
public void ToStringTest()
{
var expected = "9c";
var data = new byte[] { 156 };
var actual = HexConvert.ToString(data, lowerCase: true);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayTest()
{
var baseNCharBytes = "9c".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNCharBytes);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayPartialTest()
{
var baseNChars = "999c99".ToCharArray();
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNChars, 2, baseNChars.Length - 4);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayTest()
{
var baseNChars = "9c".ToCharArray();
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNChars);
Assert.Equal(expected, actual);
}
public void ToCharArrayPartialTest()
{
var expected = "9c".ToCharArray();
var data = new byte[] { 255, 156, 255 };
var actual = HexConvert.ToCharArray(data, 1, 1, lowerCase: true);
Assert.Equal(expected, actual);
}
public void ToBytesStringPartialTest()
{
var baseNString = "999c99";
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNString, 2, baseNString.Length - 4);
Assert.Equal(expected, actual);
}
public void ToByteStringTest()
{
var baseNString = "9c";
var expected = new byte[] { 156 };
var actual = HexConvert.ToBytes(baseNString);
Assert.Equal(expected, actual);
}
public void ConvertsCorrectly(byte[] bytes, string expectedHex)
{
string hex = HexConvert.ToHexString(bytes);
Assert.Equal(expectedHex, hex);
byte[] resultBytes = HexConvert.FromHexString(hex);
Assert.Equal(bytes, resultBytes);
}
protected void LinkButtonUploadMiningUser_Click(object sender, EventArgs e)
{
var selectedUser = DropDownList1.SelectedValue;
var user = DataManager.UploadUser(selectedUser);
//TextArea1.Value = JsonConvert.SerializeObject(user, Formatting.Indented);
var receiver = new UdpClient(9999);
IPEndPoint remoteIp = null;
try
{
var data = receiver.Receive(ref remoteIp);
var transaction = MessagePackSerializer.Deserialize <Transaction>(data);
var additionalOutEntry = new OutEntry()
{
RecipientHash = user.KeyPair.PublicKey,
Value = 10
};
transaction.OutEntries.Add(additionalOutEntry);
var block = Mining.ComputeBlock(transaction);
var chain = new KeyValuePair <string, Block>(
HexConvert.FromBytes(DataManager.UploadBlockchainDictionary().Last().Value.Hash),
block);
DataManager.UpdateBlockchain(chain);
Session["last chain"] = chain;
Thread.Sleep(500);
var senderUdpClient = new UdpClient();
var message = MessagePackSerializer.Serialize(chain);
senderUdpClient.Send(
message,
message.Length,
"127.0.0.1",
remoteIp.Port);
senderUdpClient.Close();
}
finally
{
var json = JsonConvert.SerializeObject(
(KeyValuePair <string, Block>)Session["last chain"], Formatting.Indented);
receiver.Close();
TextArea1.Value = json;
//Label1.Text = json;
//Label1.Text = json.ToJonHtml();
}
}
public void HexConvert_FromBytes_ToBytes_GoodResult()
{
//Arrange
var hash = Hash.ComputeSha256(new byte[0]);
var hashstring = HexConvert.FromBytes(hash);
var str = hashstring;
//Act
//Assert
Assert.AreEqual(hash, HexConvert.ToBytes(str));
}
public static string SendMMSToWG(string id, string pwd, string Mobile, string Subject, string Content)
{
string result = "";
string subject = HexConvert.StringToHexString(Subject, SendMessage.encode);
string d = Convert.ToString(1);
string tt = "txt";
string file = HttpContext.Current.Server.MapPath("");
string tv = HexConvert.GetHexString(HexConvert.FileToBytes(file + "\\Readme.txt"));
string pt = "jpg";
string pv = HexConvert.GetHexString(QRCodeImage.imageToByte(Content));
string url = "http://118.144.76.79:8080/mmsServer/sendMms";
string postdata = string.Concat(new string[]
{
"id=",
id,
"&pwd=",
pwd,
"&subject=",
subject,
"&d1=",
d,
"&tt1=",
tt,
"&tv1=",
tv,
"&pt1=",
pt,
"&pv1=",
pv,
"&mt1=&mv1="
});
string mms_id = SendMessage.PostSend(url, postdata);
if (mms_id != null & int.Parse(mms_id) > 0)
{
url = "http://118.144.76.79:8080/mmsServer/sendMobile";
postdata = string.Concat(new string[]
{
"id=",
id,
"&pwd=",
pwd,
"&yw=10690029yd&mobile=",
Mobile,
"&mms_id=",
mms_id
});
result = SendMessage.PostSend(url, postdata);
}
return(result);
}
public static StringBuilder Read(string path)
{
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
using (BinaryReader br = new BinaryReader(fs))
{
StringBuilder data = new StringBuilder();
try
{
while (true)
{
data.Append(HexConvert.ByteToHex(br.ReadByte()));
}
}
catch (Exception)
{
return(data);
}
}
}
}
public void BufferToHexConvertTest(int count)
{
var expectedBuffer = new byte[count];
new Random(count).NextBytes(expectedBuffer);
var expectedHexString = BitConverter.ToString(expectedBuffer).Replace("-", "").ToLowerInvariant();
var expectedHexBuffer = expectedHexString.ToCharArray();
// buffer -> hex string
var hexString = HexConvert.ToString(expectedBuffer, 0, expectedBuffer.Length);
Assert.Equal(expectedHexString, hexString);
// buffer -> hex buffer
var hexBuffer = HexConvert.ToCharArray(expectedBuffer, 0, expectedBuffer.Length);
Assert.Equal(expectedHexBuffer, hexBuffer);
// buffer -> hex buffer (copy)
hexBuffer = new char[expectedHexBuffer.Length];
HexConvert.Encode(new ArraySegment <byte>(expectedBuffer, 0, expectedBuffer.Length), new ArraySegment <char>(hexBuffer));
Assert.Equal(expectedHexBuffer, hexBuffer);
}
public static void ReceiveMessage()
{
var receiver = new UdpClient(ReceiverPort); // UdpClient для получения данных
IPEndPoint remoteIp = null; // Адрес входящего подключения
try
{
while (true)
{
var data = receiver.Receive(ref remoteIp); // Получаем данные
Console.WriteLine($"Собеседник: {HexConvert.FromBytes(data)}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
receiver.Close();
}
}
public void NumbersToHexConvertTest(int seed)
{
var random = new Random(seed);
var uint8 = unchecked ((byte)(random.Next() % byte.MaxValue));
var uint16 = unchecked ((ushort)(random.Next() % ushort.MaxValue));
var uint32 = unchecked ((uint)random.Next());
var uint64 = unchecked ((ulong)random.NextDouble() * long.MaxValue);
var uint8Hex = BitConverter.ToString(new byte[] { uint8 }).Replace("-", "").ToLowerInvariant();
var uint16Hex = BitConverter.ToString(BitConverter.GetBytes(uint16)).Replace("-", "").ToLowerInvariant();
var uint32Hex = BitConverter.ToString(BitConverter.GetBytes(uint32)).Replace("-", "").ToLowerInvariant();
var uint64Hex = BitConverter.ToString(BitConverter.GetBytes(uint64)).Replace("-", "").ToLowerInvariant();
var hexBuffer = new char[256];
// uint8 -> hex
var count = HexConvert.WriteTo(uint8, hexBuffer, 0);
var actualHex = new string(hexBuffer, 0, count);
Assert.Equal(uint8Hex, actualHex);
Array.Clear(hexBuffer, 0, hexBuffer.Length);
// uint16 -> hex
count = HexConvert.WriteTo(uint16, hexBuffer, 0);
actualHex = new string(hexBuffer, 0, count);
Assert.Equal(uint16Hex, actualHex);
Array.Clear(hexBuffer, 0, hexBuffer.Length);
// uint32 -> hex
count = HexConvert.WriteTo(uint32, hexBuffer, 0);
actualHex = new string(hexBuffer, 0, count);
Assert.Equal(uint32Hex, actualHex);
Array.Clear(hexBuffer, 0, hexBuffer.Length);
// uint64 -> hex
count = HexConvert.WriteTo(uint64, hexBuffer, 0);
actualHex = new string(hexBuffer, 0, count);
Assert.Equal(uint64Hex, actualHex);
Array.Clear(hexBuffer, 0, hexBuffer.Length);
}
public void HexBytesDecodeTest(int count)
{
var outputBytes = new byte[count];
var r = new Random(count);
r.NextBytes(outputBytes);
var base64String = BitConverter.ToString(outputBytes).Replace("-", "").ToLowerInvariant();
var base64Buffer = base64String.ToCharArray().Select(v => (byte)v).ToArray();
// transform block
var inputOffset = r.Next(0, 100);
var inputBuffer = new byte[inputOffset + base64Buffer.Length + inputOffset];
Buffer.BlockCopy(base64Buffer, 0, inputBuffer, inputOffset, base64Buffer.Length);
var outputOffset = r.Next(0, 100);
var outputBuffer = new byte[outputOffset + outputBytes.Length];
var written = HexConvert.Decode(new ArraySegment <byte>(inputBuffer, inputOffset, base64Buffer.Length), new ArraySegment <byte>(outputBuffer, outputOffset, outputBuffer.Length - outputOffset), out var inputUsed, out var outputUsed);
var actualOutput = outputBuffer.Skip(outputOffset).ToArray();
Assert.Equal(outputBytes.Length, written);
Assert.Equal(outputBytes.Length, outputUsed);
Assert.Equal(base64Buffer.Length, inputUsed);
Assert.Equal(outputBytes, actualOutput);
}
public void ThrowsWhenBytesNull()
{
Assert.Throws <ArgumentNullException>(() => HexConvert.ToHexString(null));
}
private void ButtonToPay_Click(object sender, RoutedEventArgs e)
{
if (int.Parse(TextBoxAmountAct.Text) > Amount)
{
MessageBox.Show("Error!", "You haven't avaliable ACT for makking transaction.", MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
var recipientUserHash = HexConvert.ToBytes(TextBoxRecipientId.Text);
var inEntry = new InEntry()
{
PublicKey = _userCoinPocket.KeyPair.PublicKey,
Amount = Amount
};
var outEntry = new List <OutEntry>(15)
{
new OutEntry()
{
RecipientHash = recipientUserHash,
Value = int.Parse(TextBoxAmountAct.Text)
},
new OutEntry()
{
RecipientHash = _userCoinPocket.KeyPair.PublicKey,
Value = Amount - int.Parse(TextBoxAmountAct.Text)
}
};
var transaction = new Transaction()
{
Id = DataManager.UploadBlockchainDictionary().Last().Value.Transaction.Id + 1,
InEntries = new List <InEntry>()
{
inEntry
},
OutEntries = outEntry,
Signature = EccService.Sign(_userCoinPocket.KeyPair.PublicKey, _userCoinPocket.KeyPair.PrivateKey,
_userCoinPocket.KeyPair.PublicKey),
Timestamp = DateTime.Now
};
var message = BlockchainUtil.SerializeTransaction(transaction);
var senderUdpClient = new UdpClient(_userCoinPocket.ReceivePort);
try
{
senderUdpClient.Send(
message,
message.Length,
"127.0.0.1",
9999);
}
catch
{
throw new Exception();
}
finally
{
senderUdpClient.Close();
}
var receiver = new UdpClient(_userCoinPocket.ReceivePort);
IPEndPoint remoteIp = null;
var data = receiver.Receive(ref remoteIp);
var chain = MessagePackSerializer.Deserialize <KeyValuePair <string, Block> >(data);
var json = JsonConvert.SerializeObject(chain, Formatting.Indented);
GroupBoxStatus.Header = "You trancsaction has been added";
var blockchain = DataManager.UploadBlockchainDictionary();
TextBlockAct.Text = Executor
.GetCashRec(blockchain, _userCoinPocket.KeyPair.PublicKey, blockchain.Last().Key).ToString();
TextBlockStatus.Text = json;
receiver.Close();
}
private void ButtonUploadRecipient_Click(object sender, RoutedEventArgs e)
{
var user = DataManager.UploadUser();
TextBoxRecipientId.Text = HexConvert.FromBytes(user.KeyPair.PublicKey);
}
