public void LinearDictionaryCoder()
{
var testPath = "linearDictionaryUnitTest";
if (File.Exists(testPath))
{
File.Delete(testPath);
}
var linearDictionaryCoder = new LinearDictionaryEncoder(testPath, 32, 32);
var expectedDictionary = new Dictionary <byte[], byte[]>();
LargeInteger value = 0;
for (int i = 0; i < 1500; i++)
{
var valueBytes = ByteManipulator.BigEndianTruncate(value.GetBytes(), 32);
var key = CryptographyHelper.Sha3256(valueBytes);
linearDictionaryCoder.Add(key, valueBytes);
expectedDictionary.Add(key, valueBytes);
value = value + 1;
}
foreach (var kvp in expectedDictionary)
{
var entryValue = linearDictionaryCoder.Get(kvp.Key);
Assert.IsTrue(ArrayManipulator.Compare(kvp.Value, entryValue));
}
}
public async Task <Block> MineRound(Wallet wallet)
{
minedBlock.MinerAddress = wallet.PublicKey;
var difficultyBytes = minedBlock.Difficulty.GetBytes();
for (int i = 0; i < hashesPerRound; i++)
{
if (stop)
{
break;
}
minedBlock.Nonce = nonce.GetBytes();
numberOfAttempts = numberOfAttempts + 1;
if (ArrayManipulator.IsGreater(ByteManipulator.BigEndianTruncate(difficultyBytes, 32), minedBlock.GetHash(), difficultyBytes.Length)) //new block found
{
stopWatch.Stop();
return(minedBlock);
}
nonce = nonce + 1;
}
return(null);
}
public Block(byte[] rlp)
{
var decoded = RLP.Decode(rlp);
if (decoded.Count == 7 && decoded[1] != null)
{
Height = (int)(decoded[0] != null ? ByteManipulator.GetUInt32(decoded[0]) : 0);
Timestamp = ByteManipulator.GetUInt32(decoded[1]);
Difficulty = new LargeInteger(decoded[2] ?? new byte[32]);
Nonce = decoded[3] != null?ByteManipulator.BigEndianTruncate(decoded[3], 32) : new byte[32];
MinerAddress = decoded[4] != null?ByteManipulator.BigEndianTruncate(decoded[4], 33) : new byte[33];
PreviousBlockHash = decoded[5] != null?ByteManipulator.BigEndianTruncate(decoded[5], 32) : new byte[32];
var decodedTransactions = RLP.Decode(decoded[6]);
Transactions = new List <Transaction>();
if (decodedTransactions != null)
{
foreach (var rlpTransaction in decodedTransactions)
{
var tx = new Transaction(rlpTransaction);
Transactions.Add(tx);
}
}
}
else
{
throw new Exception("Invalid block");
}
}
public void Add(byte[] key, byte[] value)
{
value = ByteManipulator.BigEndianTruncate(value, DataLength);
key = ByteManipulator.BigEndianTruncate(key, KeyLength);
if (LinearCoder.Count == 0)
{
LinearCoder.Push(CreateEntry(key, value));
}
else
{
int minimum = 0;
int maximum = LinearCoder.Count - 1;
while (minimum <= maximum)
{
int middle = (minimum + maximum) / 2;
var middleValue = LinearCoder.Read(middle);
if (ArrayManipulator.Compare(key, middleValue.Take(key.Length).ToArray()))
{
throw new Exception("Key already exists");
}
else if (ArrayManipulator.IsGreater(key, middleValue, KeyLength))
{
minimum = middle + 1;
}
else
{
maximum = middle - 1;
}
}
var popCount = LinearCoder.Count - minimum;
if ((maximum >= 0) && ArrayManipulator.IsGreater(LinearCoder.Read(maximum), key, KeyLength))
{
popCount++;
}
List <byte[]> popedItems;
if (popCount != 0)
{
popedItems = LinearCoder.BulkPop(popCount);
}
else
{
popedItems = new List <byte[]>();
}
popedItems.Insert(0, CreateEntry(key, value));
LinearCoder.BulkPush(popedItems);
}
}
private void Deserialize(byte[] rlp)
{
var data = RLP.Decode(rlp);
Nonce = ByteManipulator.GetUInt32(data[0] ?? new byte[] { 0 });
Ammount = new LargeInteger(data[1] ?? new byte[] { 0 });
Fee = new LargeInteger(data[2] ?? new byte[] { 0 });
Source = ByteManipulator.BigEndianTruncate(data[3], 33) ?? new byte[33];
Destination = ByteManipulator.BigEndianTruncate(data[4], 33) ?? new byte[33];
Signature = ByteManipulator.BigEndianTruncate(data[5], 64) ?? new byte[64];
Network = data[6] ?? new byte[] { 0 };
}
public void ExtendUnitTest()
{
var input = new byte[] { 21, 5, 128, 123, 45, 0, 11 };
var expected = new byte[] { 128, 123, 45, 0, 11 };
var actual = ByteManipulator.BigEndianTruncate(input, 5);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual[i]);
}
}
public bool ContainsKey(byte[] key)
{
key = ByteManipulator.BigEndianTruncate(key, KeyLength);
if (GetIndex(key) < 0)
{
return(false);
}
else
{
return(true);
}
}
public byte[] Get(byte[] key)
{
key = ByteManipulator.BigEndianTruncate(key, KeyLength);
byte[] ret = null;
var index = GetIndex(key);
if (index != -1)
{
ret = LinearCoder.Read(index);
ret = ArrayManipulator.SubArray(ret, KeyLength, DataLength);
}
return(ret);
}
public async Task <Block> MineRound()
{
var block = new Block()
{
Difficulty = difficulty,
Height = height,
MinerAddress = minerAddress,
PreviousBlockHash = previousBlockHash,
Timestamp = timestamp,
Transactions = transactions
};
var difficultyBytes = difficulty.GetBytes();
for (int i = 0; i < hashesPerRound; i++)
{
block.Nonce = nonce.GetBytes();
numberOfAttempts = numberOfAttempts + 1;
if (ArrayManipulator.IsGreater(ByteManipulator.BigEndianTruncate(difficultyBytes, 32), block.GetHash(), difficultyBytes.Length)) //new block found
{
lock (GateKeeper.ChainManagerLock)
{
_chainManager.ProcessBlocks(new List <Block>()
{
block
});
}
lock (GateKeeper.TransactionPoolLock)
{
lock (GateKeeper.BalanceLedgerLock)
{
_transactionPool.Clean();
}
}
BlockTime = block.Timestamp - lastBlockTimeStamp;
return(block);
}
nonce = nonce + 1;
}
return(null);
}
public uint GetTransactionCount(byte[] publicKey)
{
publicKey = ByteManipulator.BigEndianTruncate(publicKey, 33);
var nonceBytes = nonceCoder.Get(publicKey);
uint ret = 0;
if (nonceBytes != null)
{
ret = ByteManipulator.GetUInt32(nonceBytes) + 1;
}
else
{
ret = 0;
}
return(ret);
}
public async void AddContact(string url)
{
if (url != null)
{
var hostnameBytes = ToBytes(url);
if (hostnameBytes != null)
{
if (!coder.ContainsKey(ByteManipulator.BigEndianTruncate(hostnameBytes, 128)))
{
if (await Handshake(url))
{
coder.Add(hostnameBytes, ByteManipulator.GetBytes((uint)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds));
}
}
}
}
}
byte[] CreateEntry(byte[] key, byte[] value)
{
key = ByteManipulator.BigEndianTruncate(key, KeyLength);
value = ByteManipulator.BigEndianTruncate(value, DataLength);
var buffer = new byte[KeyLength + DataLength];
for (int i = 0; i < key.Length; i++)
{
buffer[i] = key[i];
}
for (int i = 0; i < value.Length; i++)
{
buffer[i + key.Length] = value[i];
}
return(buffer);
}
public Miner(BalanceLedger balanceLedger, TransactionPool transactionPool, ChainManager chainManager)
{
_balanceLedger = balanceLedger;
_transactionPool = transactionPool;
_chainManager = chainManager;
var minerAddressBytes = HexConverter.ToBytes(Program.Settings.minerAddr);
if (minerAddressBytes != null && minerAddressBytes.Length < 34)
{
minerAddress = ByteManipulator.BigEndianTruncate(minerAddressBytes, 33);
Console.WriteLine($"[Miner] Miner initialized with address {HexConverter.ToPrefixString(minerAddress)}");
}
else
{
Console.WriteLine("[Miner] Warning: Invalid address. Miner initialized with address 0x0");
minerAddress = new byte[33];
}
}
public void BulkPush(List <byte[]> data)
{
var buffer = new byte[data.Count * DataLength];
int counter = 0;
foreach (var entry in data)
{
var extendedEntry = ByteManipulator.BigEndianTruncate(entry, DataLength);
for (int i = 0; i < DataLength; i++)
{
buffer[counter++] = extendedEntry[i];
}
}
fileStream.Write(buffer);
fileStream.Flush();
ReevaluateProperties();
}
public async Task <bool> AddContact(string url)
{
var ret = false;
if (url != null)
{
var hostnameBytes = ToBytes(url);
if ((hostnameBytes != null) && (url != Program.Settings.url))
{
if (!coder.ContainsKey(ByteManipulator.BigEndianTruncate(hostnameBytes, 128)))
{
if (await Handshake(url))
{
coder.Add(hostnameBytes, ByteManipulator.GetBytes((uint)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds));
ret = true;
}
}
}
}
return(ret);
}
public void RemoveContact(string url)
{
var bytes = ByteManipulator.BigEndianTruncate(Encoding.UTF8.GetBytes(url), 128);
coder.Remove(bytes);
}
public void Remove(byte[] key)
{
key = ByteManipulator.BigEndianTruncate(key, KeyLength);
LinearCoder.Remove(GetIndex(key));
}
public Block GetBlock(byte[] hash)
{
hash = ByteManipulator.BigEndianTruncate(hash, 33);
return(main.GetByHash(hash));
}
