public Block GetBlock(uint256 id, List<byte[]> searchedData)
{
var block = Get(id);
if(block == null)
return null;
return block;
}
public Transaction GetFromCache(uint256 txId)
{
using(@lock.LockRead())
{
return _Transactions.TryGet(txId);
}
}
public void ComputeChecksum(uint256 hashBlock)
{
MemoryStream ms = new MemoryStream();
hashBlock.ReadWrite(ms, true);
this.ReadWrite(ms, true);
CalculatedChecksum = Hashes.Hash256(ms.ToArray());
}
public void Setup()
{
var value = new Span <byte>(new byte[32]);
new Random().NextBytes(value);
_nBitcoinData = new uint256(value.ToArray());
_mithrilShardsData = new Core.DataTypes.UInt256(value);
}
public BlockHeader GetHeader(uint256 hash)
{
var pos = _Index.Get<DiskBlockPos>(hash.ToString());
if(pos == null)
return null;
var stored = _Store.Enumerate(false, new DiskBlockPosRange(pos)).FirstOrDefault();
if(stored == null)
return null;
return stored.Item.Header;
}
public static void Put(this ITransactionRepository repo, uint256 txId, Transaction tx)
{
try
{
repo.PutAsync(txId, tx).Wait();
}
catch(AggregateException aex)
{
ExceptionDispatchInfo.Capture(aex.InnerException).Throw();
}
}
public Task PutAsync(uint256 txId, Transaction tx)
{
using(@lock.LockWrite())
{
if(!_Transactions.ContainsKey(txId))
_Transactions.AddOrReplace(txId, tx);
else
_Transactions[txId] = tx;
}
return _Inner.PutAsync(txId, tx);
}
public uint256(uint256 b)
{
pn0 = b.pn0;
pn1 = b.pn1;
pn2 = b.pn2;
pn3 = b.pn3;
pn4 = b.pn4;
pn5 = b.pn5;
pn6 = b.pn6;
pn7 = b.pn7;
}
static void Main(string[] args)
{
// Example 3-3. Running getinfo via Bitcoin Core’s JSON-RPC API - Seite 49
// Benutze den RPC Wrapper von NBitcoin:
NetworkCredential myCredential = new NetworkCredential("bitcoinrpc", "d0n7Blue");
Uri myUri = new Uri("http://localhost.:8332/");
RPCClient myClient = new RPCClient(myCredential, myUri);
int blockheight = myClient.GetBlockCount();
Console.WriteLine($"Anzahl Blöcke/Blockheight: {blockheight}");
// Example 3-4. Retrieving a transaction and iterating its outputs
// Alice's transaction ID
NBitcoin.uint256 txid = uint256.Parse("0627052b6f28912f2703066a912ea577f2ce4da4caa5a5fbd8a57286c345c2f2");
// First, retrieve the raw transaction in hex
string raw_tx = myClient.GetRawTransaction(txid).ToString();
Console.WriteLine(raw_tx);
// Decode the transaction hex into a JSON object
//Transaction decodedTx = myClient.DecodeRawTransactionAsync(raw_tx);
//Transaction decodedTx = myClient.DecodeRawTransaction(raw_tx);
//Console.WriteLine(raw_tx);
//var outputList = raw_tx.Outputs;
//foreach (var output in outputList)
//{
// Console.WriteLine(output);
//}
// Example 3-5. Retrieving a block and adding all the transaction outputs - Seite 50
int blockheightOfAliceTransaction = 277316;
// Get the block hash of block with height 277316
var blockhash = myClient.GetBlockHash(blockheightOfAliceTransaction);
// Retrieve the block by its hash
var block = myClient.GetBlock(blockhash);
var listOfTransactions = block.Transactions;
Console.WriteLine($"blockheight of Alice's Transaction: {blockheightOfAliceTransaction}\n Blockhash: {blockhash}\n");
NBitcoin.Money sumOfTrans = 0;
foreach (var trans in listOfTransactions)
{
sumOfTrans += trans.TotalOut;
}
// Die Summe stimmt! Siehe Seite 51:
Console.WriteLine($"Bitcoin Wert insgesamt des Blocks: {sumOfTrans.ToString()}");
}
public static Transaction Get(this ITransactionRepository repo, uint256 txId)
{
try
{
return repo.GetAsync(txId).Result;
}
catch(AggregateException aex)
{
ExceptionDispatchInfo.Capture(aex.InnerException).Throw();
return null;
}
}
public async Task<Transaction> GetAsync(uint256 txId)
{
using(HttpClient client = new HttpClient())
{
var tx = await client.GetAsync(BaseUri.AbsoluteUri + "transactions/" + txId + "?format=raw").ConfigureAwait(false);
if(tx.StatusCode == System.Net.HttpStatusCode.NotFound)
return null;
tx.EnsureSuccessStatusCode();
var bytes = await tx.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
return new Transaction(bytes);
}
}
// Construct a partial merkle tree from a list of transaction id's, and a mask that selects a subset of them
public PartialMerkleTree(uint256[] vTxid, bool[] vMatch)
{
fBad = false;
nTransactions = (uint)vTxid.Length;
// calculate height of tree
int nHeight = 0;
while(CalcTreeWidth(nHeight) > 1)
nHeight++;
// traverse the partial tree
TraverseAndBuild(nHeight, 0, vTxid, vMatch);
}
public static uint256 CheckMerkleBranch(uint256 hash, List<uint256> vMerkleBranch, int nIndex)
{
if(nIndex == -1)
return 0;
foreach(var otherside in vMerkleBranch)
{
if((nIndex & 1) != 0)
hash = Hash(otherside, hash);
else
hash = Hash(hash, otherside);
nIndex >>= 1;
}
return hash;
}
public MerkleBlock(Block block, uint256[] txIds)
{
header = block.Header;
List<bool> vMatch = new List<bool>();
List<uint256> vHashes = new List<uint256>();
for(int i = 0 ; i < block.Transactions.Count ; i++)
{
var hash = block.Transactions[i].GetHash();
vHashes.Add(hash);
vMatch.Add(txIds.Contains(hash));
}
_PartialMerkleTree = new PartialMerkleTree(vHashes.ToArray(), vMatch.ToArray());
}
public static bool TryParse(string hex, out uint256 result)
{
if(hex == null)
throw new ArgumentNullException("hex");
result = null;
if(hex.Length != WIDTH_BYTE * 2)
return false;
if(!((HexEncoder)Encoders.Hex).IsValid(hex))
return false;
var ret = new uint256();
ret.SetHex(hex);
result = ret;
return true;
}
public void ReadWrite(BitcoinStream stream)
{
if(stream.Serializing)
{
var b = Value.ToBytes();
stream.ReadWrite(ref b);
}
else
{
byte[] b = new byte[WIDTH_BYTE];
stream.ReadWrite(ref b);
_Value = new uint256(b);
}
}
public static bool TryParse(string hex, out uint256 result)
{
if(hex == null)
throw new ArgumentNullException("hex");
if (hex.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
hex = hex.Substring(2);
result = null;
if(hex.Length != WIDTH_BYTE * 2)
return false;
if(!((HexEncoder)Encoders.Hex).IsValid(hex))
return false;
result = new uint256(hex);
return true;
}
public PartialMerkleTree(uint256[] vTxid, bool[] vMatch)
{
if(vMatch.Length != vTxid.Length)
throw new ArgumentException("The size of the array of txid and matches is different");
TransactionCount = (uint)vTxid.Length;
MerkleNode root = MerkleNode.GetRoot(vTxid);
BitWriter flags = new BitWriter();
MarkNodes(root, vMatch);
BuildCore(root, flags);
Flags = flags.ToBitArray();
}
public static List <NB.Coin> GetUnspentCoins(Data walletData, bool JustConfirmed = true)
{
var UnspentCoins = new List <NB.Coin>();
foreach (var outp in walletData.unspent_Outputs)
{
var address = NB.BitcoinAddress.Create(outp.address);
var hash = new NB.uint256(outp.hash);
var amount = new NB.Money(outp.value, NB.MoneyUnit.BTC);
if (outp.confirmations < 3 && JustConfirmed)
{
continue;
}
UnspentCoins.Add(new NB.Coin(hash, (uint)outp.index, amount, address.ScriptPubKey));
}
return(UnspentCoins);
}
public async Task<Transaction> GetAsync(uint256 txId)
{
bool found = false;
Transaction result = null;
using(@lock.LockRead())
{
found = _Transactions.TryGetValue(txId, out result);
}
if(!found)
{
result = await _Inner.GetAsync(txId).ConfigureAwait(false);
using(@lock.LockWrite())
{
_Transactions.AddOrReplace(txId, result);
}
}
return result;
}
public Task PutAsync(uint256 txId, Transaction tx)
{
if(WriteThrough)
{
using(@lock.LockWrite())
{
if(!_Transactions.ContainsKey(txId))
{
_Transactions.AddOrReplace(txId, tx);
EvictIfNecessary(txId);
}
else
_Transactions[txId] = tx;
}
}
return _Inner.PutAsync(txId, tx);
}
// (memory only) Sequencial id assigned to distinguish order in which blocks are received.
//uint nSequenceId;
public ChainedBlock(BlockHeader header,uint256 headerHash, ChainedBlock previous)
{
if(previous != null)
{
nHeight = previous.Height + 1;
}
this.pprev = previous;
//this.nDataPos = pos;
this.header = header;
this.phashBlock = headerHash ?? header.GetHash();
if(previous == null)
{
if(header.HashPrevBlock != 0)
throw new ArgumentException("Only the genesis block can have no previous block");
}
else
{
if(previous.HashBlock != header.HashPrevBlock)
throw new ArgumentException("The previous block has not the expected hash");
}
}
public Block GetBlock(uint256 blockId)
{
var ms = new MemoryStream();
var container = Configuration.GetBlocksContainer();
try
{
container.GetPageBlobReference(blockId.ToString()).DownloadToStream(ms);
ms.Position = 0;
Block b = new Block();
b.ReadWrite(ms, false);
return b;
}
catch(StorageException ex)
{
if(ex.RequestInformation != null && ex.RequestInformation.HttpStatusCode == 404)
{
return null;
}
throw;
}
}
public async Task<Transaction> GetAsync(uint256 txId)
{
while(true)
{
using(HttpClient client = new HttpClient())
{
var response = await client.GetAsync(BlockrAddress + "tx/raw/" + txId).ConfigureAwait(false);
if(response.StatusCode == HttpStatusCode.NotFound)
return null;
var result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var json = JObject.Parse(result);
var status = json["status"];
var code = json["code"];
if(status != null && status.ToString() == "error")
{
throw new BlockrException(json);
}
var tx = new Transaction(json["data"]["tx"]["hex"].ToString());
return tx;
}
}
}
public ECDSASignature Sign(uint256 hash)
{
return _ECKey.Sign(hash);
}
private void InitMain()
{
SpendableCoinbaseDepth = 100;
name = "Main";
// The message start string is designed to be unlikely to occur in normal data.
// The characters are rarely used upper ASCII, not valid as UTF-8, and produce
// a large 4-byte int at any alignment.
magic = 0xD9B4BEF9;
vAlertPubKey = Encoders.Hex.DecodeData("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284");
nDefaultPort = 8333;
nRPCPort = 8332;
_ProofOfLimit = new Target(~uint256.Zero >> 32);
nSubsidyHalvingInterval = 210000;
Transaction txNew = new Transaction();
txNew.Version = 1;
txNew.Inputs.Add(new TxIn());
txNew.Outputs.Add(new TxOut());
txNew.Inputs[0].ScriptSig = new Script(Encoders.Hex.DecodeData("04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73"));
txNew.Outputs[0].Value = 50 * Money.COIN;
txNew.Outputs[0].ScriptPubKey = new Script() + Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") + OpcodeType.OP_CHECKSIG;
genesis.Transactions.Add(txNew);
genesis.Header.HashPrevBlock = 0;
genesis.UpdateMerkleRoot();
genesis.Header.Version = 1;
genesis.Header.BlockTime = Utils.UnixTimeToDateTime(1231006505);
genesis.Header.Bits = 0x1d00ffff;
genesis.Header.Nonce = 2083236893;
hashGenesisBlock = genesis.GetHash();
assert(hashGenesisBlock == uint256.Parse("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
assert(genesis.Header.HashMerkleRoot == uint256.Parse("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
#if !PORTABLE
vSeeds.Add(new DNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be"));
vSeeds.Add(new DNSSeedData("bluematt.me", "dnsseed.bluematt.me"));
vSeeds.Add(new DNSSeedData("dashjr.org", "dnsseed.bitcoin.dashjr.org"));
vSeeds.Add(new DNSSeedData("bitcoinstats.com", "seed.bitcoinstats.com"));
vSeeds.Add(new DNSSeedData("bitnodes.io", "seed.bitnodes.io"));
vSeeds.Add(new DNSSeedData("xf2.org", "bitseed.xf2.org"));
vSeeds.Add(new DNSSeedData("bitcoin.jonasschnelli.ch", "seed.bitcoin.jonasschnelli.ch"));
#endif
base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (0) };
base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (5) };
base58Prefixes[(int)Base58Type.SECRET_KEY] = new byte[] { (128) };
base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC] = new byte[] { 0x01, 0x42 };
base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC] = new byte[] { 0x01, 0x43 };
base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY] = new byte[] { (0x04), (0x88), (0xB2), (0x1E) };
base58Prefixes[(int)Base58Type.EXT_SECRET_KEY] = new byte[] { (0x04), (0x88), (0xAD), (0xE4) };
base58Prefixes[(int)Base58Type.PASSPHRASE_CODE] = new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 };
base58Prefixes[(int)Base58Type.CONFIRMATION_CODE] = new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A };
base58Prefixes[(int)Base58Type.STEALTH_ADDRESS] = new byte[] { 0x2a };
base58Prefixes[(int)Base58Type.ASSET_ID] = new byte[] { 23 };
base58Prefixes[(int)Base58Type.COLORED_ADDRESS] = new byte[] { 0x13 };
// Convert the pnSeeds array into usable address objects.
Random rand = new Random();
TimeSpan nOneWeek = TimeSpan.FromDays(7);
#if !PORTABLE
for (int i = 0; i < pnSeed.Length; i++)
{
// It'll only connect to one or two seed nodes because once it connects,
// it'll get a pile of addresses with newer timestamps.
IPAddress ip = IPAddress.Parse(pnSeed[i]);
NetworkAddress addr = new NetworkAddress();
// Seed nodes are given a random 'last seen time' of between one and two
// weeks ago.
addr.Time = DateTime.UtcNow - (TimeSpan.FromSeconds(rand.NextDouble() * nOneWeek.TotalSeconds)) - nOneWeek;
addr.Endpoint = new IPEndPoint(ip, DefaultPort);
vFixedSeeds.Add(addr);
}
#endif
}
public OutPoint(uint256 hashIn, int nIn)
{
hash = hashIn;
this.n = nIn == -1 ? n = uint.MaxValue : (uint)nIn;
}
public void PutAsync(uint256 trxId, uint256 blockId)
{
repository.PutAsync(trxId.ToString(), blockId.AsBitcoinSerializable());
}
// Check kernel hash target and coinstake signature
public static bool CheckProofOfStake(IBlockRepository blockStore, ITransactionRepository trasnactionStore, IBlockTransactionMapStore mapStore,
ChainedBlock pindexPrev, Transaction tx, uint nBits, out uint256 hashProofOfStake, out uint256 targetProofOfStake)
{
targetProofOfStake = null; hashProofOfStake = null;
// todo: Comments on this mehtod:
// the store objects (IBlockRepository and ITransactionRepository) should be a singleton instance of
// the BlockValidator and would be initiated as part of a Dependency Injection freamwork
if (!tx.IsCoinStake)
{
return(false); // error("CheckProofOfStake() : called on non-coinstake %s", tx.GetHash().ToString());
}
// Kernel (input 0) must match the stake hash target per coin age (nBits)
var txIn = tx.Inputs[0];
// First try finding the previous transaction in database
var txPrev = trasnactionStore.Get(txIn.PrevOut.Hash);
if (txPrev == null)
{
return(false); // tx.DoS(1, error("CheckProofOfStake() : INFO: read txPrev failed")); // previous transaction not in main chain, may occur during initial download
}
// Verify signature
if (!VerifySignature(txPrev, tx, 0, ScriptVerify.None))
{
return(false); // tx.DoS(100, error("CheckProofOfStake() : VerifySignature failed on coinstake %s", tx.GetHash().ToString()));
}
// Read block header
var blockHashPrev = mapStore.GetBlockHash(txIn.PrevOut.Hash);
var block = blockHashPrev == null ? null : blockStore.GetBlock(blockHashPrev);
if (block == null)
{
return(false); //fDebug? error("CheckProofOfStake() : read block failed") : false; // unable to read block of previous transaction
}
// Min age requirement
if (IsProtocolV3((int)tx.Time))
{
int nDepth = 0;
if (IsConfirmedInNPrevBlocks(blockStore, txPrev, pindexPrev, StakeMinConfirmations - 1, ref nDepth))
{
return(false); // tx.DoS(100, error("CheckProofOfStake() : tried to stake at depth %d", nDepth + 1));
}
}
else
{
var nTimeBlockFrom = block.Header.Time;
if (nTimeBlockFrom + StakeMinAge > tx.Time)
{
return(false); // error("CheckProofOfStake() : min age violation");
}
}
if (!CheckStakeKernelHash(pindexPrev, nBits, block, txPrev, txIn.PrevOut, tx.Time, out hashProofOfStake, out targetProofOfStake, false))
{
return(false); // tx.DoS(1, error("CheckProofOfStake() : INFO: check kernel failed on coinstake %s, hashProof=%s", tx.GetHash().ToString(), hashProofOfStake.ToString())); // may occur during initial download or if behind on block chain sync
}
return(true);
}
private static bool CheckStakeKernelHash(ChainedBlock pindexPrev, uint nBits, Block blockFrom, Transaction txPrev,
OutPoint prevout, uint nTimeTx, out uint256 hashProofOfStake, out uint256 targetProofOfStake, bool fPrintProofOfStake)
{
targetProofOfStake = null; hashProofOfStake = null;
if (IsProtocolV2(pindexPrev.Height + 1))
{
return(CheckStakeKernelHashV2(pindexPrev, nBits, blockFrom.Header.Time, txPrev, prevout, nTimeTx, out hashProofOfStake, out targetProofOfStake, fPrintProofOfStake));
}
else
{
return(CheckStakeKernelHashV1());
}
}
private string GetId(uint256 txId)
{
return("tx-" + txId.ToString());
}
public ECDSASignature Sign(uint256 hash)
{
return(_ECKey.Sign(hash));
}
private static bool Check(byte[] vch)
{
var candidateKey = new uint256(vch.SafeSubarray(0, KEY_SIZE));
return(candidateKey > 0 && candidateKey < N);
}
public TransactionSignature Sign(uint256 hash, SigHash sigHash)
{
return(new TransactionSignature(Sign(hash), sigHash));
}
public WitScriptId(uint256 value)
: base(value.ToBytes())
{
}
public TransactionNotFoundException(string message, uint256 txId)
: this(message, txId, null)
{
}
public TransactionNotFoundException(uint256 txId)
: this(null, txId, null)
{
}
public void PushChange(ChainChange change, uint256 blockHash)
{
Process(change, blockHash);
_Changes.WriteNext(change);
_NextToProcess++;
}
public ChainedBlock GetBlock(uint256 hash)
{
return(GetBlock(hash, false));
}
public Task <Transaction> GetAsync(uint256 txId)
{
return(this.repository.GetAsync <Transaction>(GetId(txId)));
}
public Task PutAsync(uint256 txId, Transaction tx)
{
return(Task.FromResult(false));
}
public Task PutAsync(uint256 blockId, Block block)
{
return(_Repository.PutAsync(blockId.ToString(), block));
}
public sealed override void Set(uint256 blockid, BlockStake blockStake)
{
// throw if item already exists
this.items.Add(blockid, blockStake);
}
public ChainedBlock(BlockHeader header, int height)
{
nHeight = height;
//this.nDataPos = pos;
this.header = header;
this.phashBlock = header.GetHash();
}
public override BlockStake Get(uint256 blockid)
{
return(this.items.TryGet(blockid));
}
public ChainedBlock(BlockHeader header, int height)
{
if(header == null)
throw new ArgumentNullException("header");
nHeight = height;
//this.nDataPos = pos;
this.header = header;
this.phashBlock = header.GetHash();
}
public OutPoint(uint256 hashIn, uint nIn)
{
hash = hashIn;
n = nIn;
}
public TransactionSignature Sign(uint256 hash, SigHash sigHash)
{
return new TransactionSignature(Sign(hash), sigHash);
}
public SmartContractPoABlockHeader() : base()
{
this.hashStateRoot = 0;
this.receiptRoot = 0;
this.logsBloom = new Bloom();
}
public bool Contains(uint256 hash, bool includeBranch = false)
{
ChainedBlock pindex = GetBlock(hash, includeBranch);
return(pindex != null);
}
public ChainedBlock FindAncestorOrSelf(uint256 blockHash)
{
ChainedBlock currentBlock = this;
while(currentBlock != null && currentBlock.HashBlock != blockHash)
{
currentBlock = currentBlock.Previous;
}
return currentBlock;
}
public Task <Block> GetBlockAsync(uint256 blockId)
{
return(_Repository.GetAsync <Block>(blockId.ToString()));
}
public byte[] SignCompact(uint256 hash)
{
var sig = _ECKey.Sign(hash);
// Now we have to work backwards to figure out the recId needed to recover the signature.
int recId = -1;
for(int i = 0 ; i < 4 ; i++)
{
ECKey k = ECKey.RecoverFromSignature(i, sig, hash, IsCompressed);
if(k != null && k.GetPubKey(IsCompressed).ToHex() == PubKey.ToHex())
{
recId = i;
break;
}
}
if(recId == -1)
throw new InvalidOperationException("Could not construct a recoverable key. This should never happen.");
int headerByte = recId + 27 + (IsCompressed ? 4 : 0);
byte[] sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes for S
sigData[0] = (byte)headerByte;
Array.Copy(Utils.BigIntegerToBytes(sig.R, 32), 0, sigData, 1, 32);
Array.Copy(Utils.BigIntegerToBytes(sig.S, 32), 0, sigData, 33, 32);
return sigData;
}
public Target(uint256 target)
{
_Target = new BigInteger(target.ToBytes(false));
_Target = new Target(this.ToCompact())._Target;
}
private static bool Check(byte[] vch)
{
var candidateKey = new uint256(vch.SafeSubarray(0, KEY_SIZE));
return candidateKey > 0 && candidateKey < N;
}
/// <summary>
/// If called, GetHash becomes cached, only use if you believe the instance will not be modified after calculation. Calling it a second type invalidate the cache.
/// </summary>
public void CacheHashes()
{
_Hashes = new uint256[1];
}
// select a block from the candidate blocks in vSortedByTimestamp, excluding
// already selected blocks in vSelectedBlocks, and with timestamp up to
// nSelectionIntervalStop.
private static bool SelectBlockFromCandidates(ChainedBlock chainIndex, SortedDictionary <uint, uint256> sortedByTimestamp,
Dictionary <uint256, ChainedBlock> mapSelectedBlocks,
long nSelectionIntervalStop, ulong nStakeModifierPrev, out ChainedBlock pindexSelected)
{
bool fSelected = false;
uint256 hashBest = 0;
pindexSelected = null;
foreach (var item in sortedByTimestamp)
{
var pindex = chainIndex.FindAncestorOrSelf(item.Value);
if (pindex == null)
{
return(false); // error("SelectBlockFromCandidates: failed to find block index for candidate block %s", item.second.ToString());
}
if (fSelected && pindex.Header.Time > nSelectionIntervalStop)
{
break;
}
if (mapSelectedBlocks.Keys.Any(key => key == pindex.HashBlock))
{
continue;
}
// compute the selection hash by hashing its proof-hash and the
// previous proof-of-stake modifier
uint256 hashSelection;
using (var ms = new MemoryStream())
{
var serializer = new BitcoinStream(ms, true);
serializer.ReadWrite(pindex.Header.PosParameters.HashProof);
serializer.ReadWrite(nStakeModifierPrev);
hashSelection = Hashes.Hash256(ms.ToArray());
}
// the selection hash is divided by 2**32 so that proof-of-stake block
// is always favored over proof-of-work block. this is to preserve
// the energy efficiency property
if (pindex.Header.PosParameters.IsProofOfStake())
{
hashSelection >>= 32;
}
if (fSelected && hashSelection < hashBest)
{
hashBest = hashSelection;
pindexSelected = pindex;
}
else if (!fSelected)
{
fSelected = true;
hashBest = hashSelection;
pindexSelected = pindex;
}
}
//LogPrint("stakemodifier", "SelectBlockFromCandidates: selection hash=%s\n", hashBest.ToString());
return(fSelected);
}
// Stratis kernel protocol
// coinstake must meet hash target according to the protocol:
// kernel (input 0) must meet the formula
// hash(nStakeModifier + txPrev.block.nTime + txPrev.nTime + txPrev.vout.hash + txPrev.vout.n + nTime) < bnTarget * nWeight
// this ensures that the chance of getting a coinstake is proportional to the
// amount of coins one owns.
// The reason this hash is chosen is the following:
// nStakeModifier: scrambles computation to make it very difficult to precompute
// future proof-of-stake
// txPrev.block.nTime: prevent nodes from guessing a good timestamp to
// generate transaction for future advantage,
// obsolete since v3
// txPrev.nTime: slightly scrambles computation
// txPrev.vout.hash: hash of txPrev, to reduce the chance of nodes
// generating coinstake at the same time
// txPrev.vout.n: output number of txPrev, to reduce the chance of nodes
// generating coinstake at the same time
// nTime: current timestamp
// block/tx hash should not be used here as they can be generated in vast
// quantities so as to generate blocks faster, degrading the system back into
// a proof-of-work situation.
//
private static bool CheckStakeKernelHashV2(ChainedBlock pindexPrev, uint nBits, uint nTimeBlockFrom,
Transaction txPrev, OutPoint prevout, uint nTimeTx, out uint256 hashProofOfStake, out uint256 targetProofOfStake, bool fPrintProofOfStake)
{
targetProofOfStake = null; hashProofOfStake = null;
if (nTimeTx < txPrev.Time) // Transaction timestamp violation
{
return(false); //error("CheckStakeKernelHash() : nTime violation");
}
// Base target
var bnTarget = new Target(nBits).ToBigInteger();
// Weighted target
var nValueIn = txPrev.Outputs[prevout.N].Value.Satoshi;
var bnWeight = BigInteger.ValueOf(nValueIn);
bnTarget = bnTarget.Multiply(bnWeight);
// todo: investigate this issue, is the convertion to uint256 similar to the c++ implementation
//targetProofOfStake = Target.ToUInt256(bnTarget);
var nStakeModifier = pindexPrev.Header.PosParameters.StakeModifier;
uint256 bnStakeModifierV2 = pindexPrev.Header.PosParameters.StakeModifierV2;
int nStakeModifierHeight = pindexPrev.Height;
var nStakeModifierTime = pindexPrev.Header.Time;
// Calculate hash
using (var ms = new MemoryStream())
{
var serializer = new BitcoinStream(ms, true);
if (IsProtocolV3((int)nTimeTx))
{
serializer.ReadWrite(bnStakeModifierV2);
}
else
{
serializer.ReadWrite(nStakeModifier);
serializer.ReadWrite(nTimeBlockFrom);
}
serializer.ReadWrite(txPrev.Time);
serializer.ReadWrite(prevout.Hash);
serializer.ReadWrite(prevout.N);
serializer.ReadWrite(nTimeTx);
hashProofOfStake = Hashes.Hash256(ms.ToArray());
}
if (fPrintProofOfStake)
{
//LogPrintf("CheckStakeKernelHash() : using modifier 0x%016x at height=%d timestamp=%s for block from timestamp=%s\n",
// nStakeModifier, nStakeModifierHeight,
// DateTimeStrFormat(nStakeModifierTime),
// DateTimeStrFormat(nTimeBlockFrom));
//LogPrintf("CheckStakeKernelHash() : check modifier=0x%016x nTimeBlockFrom=%u nTimeTxPrev=%u nPrevout=%u nTimeTx=%u hashProof=%s\n",
// nStakeModifier,
// nTimeBlockFrom, txPrev.nTime, prevout.n, nTimeTx,
// hashProofOfStake.ToString());
}
// Now check if proof-of-stake hash meets target protocol
var hashProofOfStakeTarget = new BigInteger(hashProofOfStake.ToBytes(false));
if (hashProofOfStakeTarget.CompareTo(bnTarget) > 0)
{
return(false);
}
// if (fDebug && !fPrintProofOfStake)
// {
// LogPrintf("CheckStakeKernelHash() : using modifier 0x%016x at height=%d timestamp=%s for block from timestamp=%s\n",
// nStakeModifier, nStakeModifierHeight,
// DateTimeStrFormat(nStakeModifierTime),
// DateTimeStrFormat(nTimeBlockFrom));
// LogPrintf("CheckStakeKernelHash() : pass modifier=0x%016x nTimeBlockFrom=%u nTimeTxPrev=%u nPrevout=%u nTimeTx=%u hashProof=%s\n",
// nStakeModifier,
// nTimeBlockFrom, txPrev.nTime, prevout.n, nTimeTx,
// hashProofOfStake.ToString());
// }
return(true);
}
public static Block GetBlock(this IBlockRepository repository, uint256 blockId)
{
return(repository.GetBlockAsync(blockId).GetAwaiter().GetResult());
}
public Task PutAsync(uint256 txId, Transaction tx)
{
return(this.repository.PutAsync(GetId(txId), tx));
}