Types.Block Child(Types.Block bk, int addHours)
{
var nonce = new byte[10];
new Random().NextBytes(nonce);
//var nonce = new byte[] { };
var timestamp = DateTime.Now.ToUniversalTime().AddHours(addHours).Ticks;
var header = new Types.BlockHeader(
0,
Merkle.blockHeaderHasher.Invoke(bk.header),
bk.header.blockNumber + 1,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
timestamp,
0,
nonce
);
var txs = new List <Types.Transaction>();
txs.Add(Utils.GetTx());
return(new Types.Block(header, ListModule.OfSeq(txs)));
}
public static Types.Block Child(this Types.Block bk)
{
var nonce = new byte[10];
new Random().NextBytes(nonce);
//var nonce = new byte[] { };
var header = new Types.BlockHeader(
0,
Merkle.blockHeaderHasher.Invoke(bk.header),
bk.header.blockNumber + 1,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
DateTime.Now.ToUniversalTime().Ticks,
0,
nonce
);
var txs = new List <Types.Transaction>();
txs.Add(Utils.GetCoinbaseTx(bk.header.blockNumber + 1));
return(new Types.Block(header, ListModule.OfSeq(txs)));
}
public static Types.Block AddTx(this Types.Block bk, Types.Transaction tx)
{
//var nonce = new byte[10];
//new Random().NextBytes(nonce);
var nonce = new byte[] { };
var header = new Types.BlockHeader(
0,
new byte[] { },
bk.header.blockNumber + 1,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
DateTime.Now.ToUniversalTime().Ticks,
0,
nonce
);
var txs = bk.transactions.ToList();
txs.Add(tx);
return(new Types.Block(bk.header, ListModule.OfSeq <Types.Transaction>(txs)));
}
public static Types.Block GetGenesisBlock()
{
var nonce = new byte[10];
new Random().NextBytes(nonce);
var header = new Types.BlockHeader(
0,
new byte[] { },
0,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
DateTime.Now.ToUniversalTime().Ticks,
0,
nonce
);
var txs = new List <Types.Transaction>();
txs.Add(GetTx());
return(new Types.Block(header, ListModule.OfSeq(txs)));
}
public void SetHeader(Types.BlockHeader header)
{
//Pause("setting header");
_Header = header;
var random = new Random();
random.NextBytes(_Header.nonce);
//Continue();
}
public static Types.Block GetBlock(Types.Block parent, Double difficulty)
{
UInt32 pdiff = Convert.ToUInt32(difficulty);
byte[] parentKey = parent == null ? new byte[] {} : Merkle.blockHeaderHasher.Invoke(parent.header);
Types.BlockHeader newBlockHeader = new Types.BlockHeader(1, parentKey, 0, new byte[] { }, new byte[] { }, new byte[] { }, ListModule.OfSeq(new List <byte[]>()), 0, pdiff, null);
var transactions = new List <Types.Transaction>();
FSharpList <Types.Transaction> newBlockTransactions = ListModule.OfSeq(transactions);
Types.Block newBlock = new Types.Block(newBlockHeader, newBlockTransactions);
return(newBlock);
}
public void Render()
{
if (Value != null)
{
return;
}
var parentKey = new byte[] { };
if (Parent != null)
{
Parent.Render();
parentKey = Parent.Value.Key;
}
uint version = 1;
string date = "2000-02-02";
var blockHeader = new Types.BlockHeader(
version,
parentKey,
0,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
DateTime.Parse(date).ToBinary(),
1,
new byte[] { }
);
//_TestTransactionPool.Render();
//var block = new Types.Block(blockHeader, ListModule.OfSeq<Types.Transaction>(_TestTransactionPool.Values.Select(t => t.Value.Value)));
var block = new Types.Block(blockHeader, ListModule.OfSeq <Types.Transaction>(_Transactions));
// byte[] key = Merkle.blockHasher.Invoke(block);
byte[] key = Merkle.blockHeaderHasher.Invoke(block.header);
Value = new Keyed <Types.Block>(key, block);
TestTrace.Transaction(Tag, key);
}
public GenesisBlock()
{
Keys = new Key[10];
CoinbaseKey = Key.Create();
for (int i = 0; i < 10; i++)
{
Keys[i] = Key.Create();
}
var nonce = new byte[10];
new Random().NextBytes(nonce);
var header = new Types.BlockHeader(
0,
new byte[] { },
0,
new byte[] { },
new byte[] { },
new byte[] { },
ListModule.OfSeq <byte[]>(new List <byte[]>()),
DateTime.Now.ToUniversalTime().Ticks,
0,
nonce
);
var txs = new List <Types.Transaction>();
txs.Add(Utils.GetCoinbaseTx(0));
for (int i = 0; i < 10; i++)
{
txs.Add(Utils.GetTx().AddOutput(Keys[i].Address, Consensus.Tests.zhash, (ulong)i * 1111));
}
Block = new Types.Block(header, ListModule.OfSeq(txs));
}
void RecalculateHeader()
{
if (_BlockChain.Tip == null)
{
return;
}
if (_TransactionQueue.IsStuck)
{
MinerTrace.Information("Queue is stuck. count = " + _TransactionQueue.Count);
}
while (!_TransactionQueue.IsStuck && _ValidatedTxs.Count < TxsPerBlockLimit)
{
var ptx = _TransactionQueue.Take();
if (IsTransactionValid(ptx))
{
_ValidatedTxs.Add(ptx);
_TransactionQueue.Remove();
HandleTx(ptx);
}
else
{
MinerTrace.Information("Tx invalid");
_TransactionQueue.Next();
}
}
if (_ValidatedTxs.Count == 0)
{
MinerTrace.Information("No txs");
return; // don't allow empty blocks
}
CalculateCoinbase();
var txs = ListModule.OfSeq(FSharpList <Types.Transaction> .Cons(_Coinbase, ListModule.OfSeq(_ValidatedTxs.Select(TransactionValidation.unpoint))));
_Header = new Types.BlockHeader(
0,
_BlockChain.Tip.Key,
_BlockChain.Tip.Value.header.blockNumber + 1,
Merkle.merkleRoot(
new byte[] { },
Merkle.transactionHasher,
txs
),
new byte[] { },
new byte[] { },
ListModule.Empty <byte[]>(),
DateTime.Now.ToUniversalTime().Ticks,
Difficulty,
new byte[12]
);
MinerTrace.Information($"Mining block number {_BlockChain.Tip.Value.header.blockNumber + 1} with {_ValidatedTxs.Count()} txs");
_Hasher.SetHeader(_Header);
_Hasher.Continue();
}
public bool IsCoinbaseTx(TransactionContext transactionContext, byte[] txHash, out Types.BlockHeader blockHeader)
{
var record = transactionContext.Transaction.Select <byte[], byte[]>(COINBASETX_BLOCK, txHash);
blockHeader = record.Exists ? Get(transactionContext, record.Value).Value.BlockHeader : null;
return(record.Exists);
}
