static void Main(string[] args) { //// 创世区块 //var blockchain = Blockchain.CreateBlockchainWithGenesisBlock(); //// 新区块 //blockchain.AddBlockToBlockchain("Send 100RMB To zhangqiang", blockchain.Blocks[blockchain.Blocks.Count - 1].Height + 1, blockchain.Blocks[blockchain.Blocks.Count - 1].Hash); //blockchain.AddBlockToBlockchain("Send 200RMB To changjingkong", blockchain.Blocks[blockchain.Blocks.Count - 1].Height + 1, blockchain.Blocks[blockchain.Blocks.Count - 1].Hash); //blockchain.AddBlockToBlockchain("Send 300RMB To juncheng", blockchain.Blocks[blockchain.Blocks.Count - 1].Height + 1, blockchain.Blocks[blockchain.Blocks.Count - 1].Hash); //blockchain.AddBlockToBlockchain("Send 50RMB To haolin", blockchain.Blocks[blockchain.Blocks.Count - 1].Height + 1, blockchain.Blocks[blockchain.Blocks.Count - 1].Hash); //Console.WriteLine(blockchain); ////fmt.Println(blockchain.Blocks) var block = new Block("Test", 1, new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); Console.WriteLine(block.Nonce); Console.WriteLine(Utils.SHA256byteArr2String(block.Hash)); var proofOfWork = new ProofOfWork(block); var b = proofOfWork.IsValid(); Console.WriteLine(b); Console.ReadLine(); }
private void ValidateBlockHash(Block block, int nonce, string hash) { if (!ProofOfWork.IsProofValid(block.Difficulty, block.Index, block.BlockDataHash, block.PreviousBlockHash, block.CreatedDate, nonce, hash)) { throw new Exception("Invalid proof of work"); } }
internal void SaveToStream(BinaryWriter bw, bool saveHash = true, bool proto1 = false) { bw.Write(BlockNumber); if (!proto1) { AccountKey.SaveToStream(bw.BaseStream, false); bw.Write(Reward); bw.Write(Fee); bw.Write(ProtocolVersion); bw.Write(AvailableProtocol); bw.Write(Timestamp); bw.Write(CompactTarget); bw.Write(Nonce); Payload.SaveToStream(bw); CheckPointHash.SaveToStream(bw); TransactionHash.SaveToStream(bw); ProofOfWork.SaveToStream(bw); } for (int i = 0; i < 5; i++) { Accounts[i].SaveToStream(bw, saveHash, !proto1); } if (proto1) { bw.Write(Timestamp); } if (saveHash) { BlockHash.SaveToStream(bw); } if (!proto1) { bw.Write(AccumulatedWork); } }
public Transaction GenerateCustomTransaction(IKeyPair owner, ProofOfWork pow, Chain chain, Func<byte[]> scriptGenerator) { var script = scriptGenerator(); var tx = MakeTransaction(owner, pow, chain, script); return tx; }
private Transaction MakeTransaction(IEnumerable <IKeyPair> signees, ProofOfWork pow, Chain chain, byte[] script) { if (!blockOpen) { throw new Exception("Call BeginBlock first"); } var tx = new Transaction(Nexus.Name, chain.Name, script, CurrentTime + TimeSpan.FromSeconds(Mempool.MaxExpirationTimeDifferenceInSeconds / 2)); Throw.If(!signees.Any(), "at least one signer required"); Signature[] existing = tx.Signatures; var msg = tx.ToByteArray(false); tx = new Transaction(Nexus.Name, chain.Name, script, CurrentTime + TimeSpan.FromSeconds(Mempool.MaxExpirationTimeDifferenceInSeconds / 2)); tx.Mine((int)pow); foreach (var kp in signees) { tx.Sign(kp); } txChainMap[tx.Hash] = chain; txHashMap[tx.Hash] = tx; transactions.Add(tx); foreach (var signer in signees) { usedAddresses.Add(Address.FromKey(signer)); } return(tx); }
public Transaction GenerateCustomTransaction(IEnumerable <KeyPair> owners, ProofOfWork pow, Chain chain, Func <byte[]> scriptGenerator) { var script = scriptGenerator(); var tx = MakeTransaction(owners, pow, chain, script); return(tx); }
private Payload GetPayload() { lock (_lock4GetPayload) if (_payload == null) { PrivateKey myPrivkeyFrom = PrivateKey.GetPrivateKey(_bm.DB, KeyFrom); if (myPrivkeyFrom == null) { throw new Exception("PrivateKey not found"); } Pubkey pubkeyTo = Pubkey.Find(_bm.DB, KeyTo); // TODO Получать ключ, если его ещё нет if (pubkeyTo == null) { throw new Exception("Pubkey not found"); } var payload = new MemoryStream(1000 + Subject.Length + Body.Length); // TODO realy 1000? var rnd = new Random(); ulong dt = DateTime.UtcNow.ToUnix() + (ulong)rnd.Next(600) - 300; payload.Write(dt); payload.WriteVarInt(Stream); var dataToEncrypt = new MemoryStream(1000 + Subject.Length + Body.Length); // TODO realy 1000? dataToEncrypt.WriteVarInt(Version); byte[] publicAddress = myPrivkeyFrom.GetPayload4Broadcast(); dataToEncrypt.Write(publicAddress, 0, publicAddress.Length); dataToEncrypt.Write(pubkeyTo.Hash, 0, 20); var encodingType = (byte)EncodingType; dataToEncrypt.Write(encodingType); dataToEncrypt.WriteVarStr("Subject:" + Subject + "\nBody:" + Body); byte[] askMsg = PayloadOfAskData().GetFullMsg(); dataToEncrypt.WriteVarInt((UInt64)askMsg.Length); dataToEncrypt.Write(askMsg, 0, askMsg.Length); byte[] signature = myPrivkeyFrom.Sign(dataToEncrypt.ToArray()); //Debug.WriteLine("data=" + dataToEncrypt.ToArray().ToHex()); //Debug.WriteLine("SigningKey=" + myPrivkeyFrom.SigningKey.ToHex()); //Debug.WriteLine("signature=" + signature.ToHex()); dataToEncrypt.WriteVarInt((UInt64)signature.Length); dataToEncrypt.Write(signature, 0, signature.Length); byte[] bytesToEncrypt = dataToEncrypt.ToArray(); byte[] encrypt = ECDSA.Encrypt(bytesToEncrypt, pubkeyTo.EncryptionKey); payload.Write(encrypt, 0, encrypt.Length); _payload = new Payload("msg", ProofOfWork.AddPow(payload.ToArray())); } return(_payload); }
static void PlayWithProofOfWork() { string text = "Marry had a little lamb"; ProofOfWork.CalculateProofOfWork(text, 0); ProofOfWork.CalculateProofOfWork(text, 1); ProofOfWork.CalculateProofOfWork(text, 2); ProofOfWork.CalculateProofOfWork(text, 3); ProofOfWork.CalculateProofOfWork(text, 4); ProofOfWork.CalculateProofOfWork(text, 5); }
public ProofOfWork Solve(ProofOfWork lastProof) { var proof = 0; ProofOfWork pow; while (!(pow = new ProofOfWork(proof)).Verify(lastProof)) { proof += 1; } return(pow); }
public void Should_Calculate_Proof_Of_Work() { // arrange var blockchain = new Blockchain(); var genesis = blockchain.Chain.First(); var expected = new ProofOfWork(72608); // act var actual = blockchain.Mine(); // assert actual.Proof.Should().Be(expected); }
private Payload GetPayload() { lock (_lock4GetPayload) if (_payload == null) { if (_version == 2) { PrivateKey privkey = PrivateKey.GetPrivateKey(_bm.DB, Key); if (privkey == null) { throw new Exception("PrivateKey not found"); } MemoryStream payload = new MemoryStream(1000 + Subject.Length + Body.Length); // TODO realy 1000? Random rnd = new Random(); ulong dt = DateTime.UtcNow.ToUnix() + (ulong)rnd.Next(600) - 300; payload.Write(dt); payload.WriteVarInt(Version); payload.WriteVarInt(Stream); MemoryStream dataToEncrypt = new MemoryStream(1000 + Subject.Length + Body.Length); // TODO realy 1000? dataToEncrypt.WriteVarInt(Version); byte[] publicAddress = privkey.GetPayload4Broadcast(); dataToEncrypt.Write(publicAddress, 0, publicAddress.Length); Byte encodingType = (byte)EncodingType; dataToEncrypt.Write(encodingType); dataToEncrypt.WriteVarStr("Subject:" + Subject + "\nBody:" + Body); byte[] signature = privkey.Sign(dataToEncrypt.ToArray()); dataToEncrypt.WriteVarInt((UInt64)signature.Length); dataToEncrypt.Write(signature, 0, signature.Length); var privEncryptionKey = privkey.Sha512VersionStreamHashFirst32(); var pubEncryptionKey = ECDSA.PointMult(privEncryptionKey); byte[] bytesToEncrypt = dataToEncrypt.ToArray(); byte[] encrypt = ECDSA.Encrypt(bytesToEncrypt, pubEncryptionKey); payload.Write(encrypt, 0, encrypt.Length); _payload = new Payload("broadcast", ProofOfWork.AddPow(payload.ToArray())); } } return(_payload); }
static void Main(string[] args) { ProofOfWork pow0 = new ProofOfWork("Mary had a little lamb", 0); ProofOfWork pow1 = new ProofOfWork("Mary had a little lamb", 1); ProofOfWork pow2 = new ProofOfWork("Mary had a little lamb", 2); ProofOfWork pow3 = new ProofOfWork("Mary had a little lamb", 3); ProofOfWork pow4 = new ProofOfWork("Mary had a little lamb", 4); ProofOfWork pow5 = new ProofOfWork("Mary had a little lamb", 5); ProofOfWork pow6 = new ProofOfWork("Mary had a little lamb", 6); pow0.CalculateProofOfWork(); pow1.CalculateProofOfWork(); pow2.CalculateProofOfWork(); pow3.CalculateProofOfWork(); pow4.CalculateProofOfWork(); pow5.CalculateProofOfWork(); pow6.CalculateProofOfWork(); }
public void SetBlockHash(IMBlock parent) { if (parent != null) { PreviousBlockHash = parent.BlockHash; parent.NextBlock = this; } else { PreviousBlockHash = null; } BuildMerkleTree(); (Nonce, BlockHash) = ProofOfWork.CalculateProofOfWork(CalculateBlockHash(PreviousBlockHash), Difficulty); if (KeyStore != null) { BlockSignature = KeyStore.SignBlock(BlockHash); } }
public Payload PayloadOfAskData() { if (_askData == null) { var payload = new MemoryStream(); var rnd = new Random(); ulong dt = DateTime.UtcNow.ToUnix() + (ulong)rnd.Next(600) - 300; payload.Write(dt); payload.WriteVarInt(Stream); var rndMsg = new byte[12 + rnd.Next(500)]; rnd.NextBytes(rndMsg); payload.Write(rndMsg, 0, rndMsg.Length); _askData = ProofOfWork.AddPow(payload.ToArray()); } return(new Payload("msg", _askData)); }
public Transaction GenerateCustomTransaction(IKeyPair owner, ProofOfWork pow, Func <byte[]> scriptGenerator) { return(GenerateCustomTransaction(owner, pow, Nexus.RootChain, scriptGenerator)); }
public Transaction GenerateCustomTransaction(IEnumerable <PhantasmaKeys> owners, ProofOfWork pow, Func <byte[]> scriptGenerator) { return(GenerateCustomTransaction(owners, pow, Nexus.RootChain, scriptGenerator)); }
private static Hash ExecuteTransaction(NexusAPI api, byte[] script, ProofOfWork proofOfWork, IKeyPair keys) { return(ExecuteTransaction(api, script, proofOfWork, new IKeyPair[] { keys })); }
private Transaction MakeTransaction(IKeyPair source, ProofOfWork pow, Chain chain, byte[] script) { return(MakeTransaction(new IKeyPair[] { source }, pow, chain, script)); }
static void Main(string[] args) { IProofOfWork proofOfWork = new ProofOfWork(); ICryptoUtil cryptoUtil = new CryptoUtil(); string minerAddress = defaultMinerAddress; string nodeAddress = defaultNodeAddress; if (args.Length > 0) { if (cryptoUtil.IsAddressValid(args[0])) { minerAddress = args[0]; } else { Output.WriteError($"Prvided address is invalid: {args[0]}. Fallback to default address: {defaultMinerAddress}"); } } if (args.Length > 1) { nodeAddress = args[1]; } Console.WriteLine($"Statring mining for address {minerAddress}"); Console.WriteLine($"Statring mining for node: {nodeAddress}"); Stopwatch sw = Stopwatch.StartNew(); BlockInput input = Get <BlockInput>(nodeAddress + "/api/mining/getBockForMine/" + minerAddress); while (true) { sw.Restart(); Boolean blockFound = false; int nonce = 0; string precomputedData = proofOfWork.PrecomputeData(input.BlockIndex, input.BlockHash, input.PrevBlockHash, input.Timestamp); Console.WriteLine($"New job started at : " + DateTime.Now + " for block index " + input.BlockIndex); string data; string blockHash; while (!blockFound && nonce < int.MaxValue) { blockHash = proofOfWork.Compute(precomputedData, nonce); if (proofOfWork.IsProofValid(blockHash, input.Difficulty)) { var blockFoundResult = MakePost(nodeAddress + "/api/mining/noncefound", new BlockMinedRequest { MinerAddress = minerAddress, Nonce = nonce, Hash = blockHash }); if (blockFoundResult) { Output.WriteSuccess($"Block mined. Nonce: {nonce} , Hash: {blockHash}"); } else { Output.WriteError("Block mined, but not accepted :("); } blockFound = true; } if (blockFound || (nonce % 1000 == 0 && sw.Elapsed >= timeLimit)) { var requestedBlockToMine = Get <BlockInput>(nodeAddress + "/api/mining/getBockForMine/" + minerAddress); if (blockFound || requestedBlockToMine.BlockHash != input.BlockHash || requestedBlockToMine.BlockIndex != input.BlockIndex) { input = requestedBlockToMine; break; } sw.Restart(); } nonce++; } } }
private static Hash ExecuteTransaction(NexusAPI api, byte[] script, ProofOfWork proofOfWork, params IKeyPair[] keys) { var tx = new Blockchain.Transaction(api.Nexus.Name, DomainSettings.RootChainName, script, Timestamp.Now + TimeSpan.FromMinutes(5), CLI.Identifier); if (proofOfWork != ProofOfWork.None) { logger.Message($"Mining proof of work with difficulty: {proofOfWork}..."); tx.Mine(proofOfWork); } logger.Message("Signing message..."); foreach (var keyPair in keys) { tx.Sign(keyPair); } var rawTx = tx.ToByteArray(true); try { api.SendRawTransaction(Base16.Encode(rawTx)); } catch (Exception e) { throw new CommandException(e.Message); } Thread.Sleep(3000); var hash = tx.Hash.ToString(); do { try { var result = api.GetTransaction(hash); } catch (Exception e) { throw new CommandException(e.Message); } /*if (result is ErrorResult) * { * var temp = (ErrorResult)result; * if (temp.error.Contains("pending")) * { * Thread.Sleep(1000); * } * else * { * throw new CommandException(temp.error); * } * } * else*/ { break; } } while (true); logger.Success($"Sent transaction with hash {hash}!"); return(Hash.Parse(hash)); }
private void VerifyPow(ProofOfWorkDetails details, byte[] proof) { var res = new ProofOfWork <SHA256>(HashHelper.Sha256, details.difficulty, details.challenge).Verify(proof); Assert.IsTrue(res); }
private static Block MakeBlock(long index, ProofOfWork proof, Sha256Hash hash, IEnumerable <Transaction> transactions) { return(new Block(index, proof, hash, transactions)); }
public static Hash ExecuteTransaction(SpookSettings settings, NexusAPI api, byte[] script, ProofOfWork proofOfWork, IKeyPair keys) { return(ExecuteTransaction(settings, api, script, proofOfWork, new IKeyPair[] { keys })); }
public string Mine([FromBody] ProofOfWork proofOfWork) { return(this._blockchain.Mine(proofOfWork.proof)); }
public static Hash ExecuteTransaction(SpookSettings settings, NexusAPI api, byte[] script, ProofOfWork proofOfWork, params IKeyPair[] keys) { var tx = new Blockchain.Transaction(settings.Node.NexusName, DomainSettings.RootChainName, script, Timestamp.Now + TimeSpan.FromMinutes(5), Spook.TxIdentifier); if (proofOfWork != ProofOfWork.None) { logger.Message($"Mining proof of work with difficulty: {proofOfWork}..."); tx.Mine(proofOfWork); } logger.Message("Signing message..."); foreach (var keyPair in keys) { tx.Sign(keyPair); } var rawTx = tx.ToByteArray(true); var encodedRawTx = Base16.Encode(rawTx); try { api.Execute("sendRawTransaction", new[] { encodedRawTx }); } catch (Exception e) { throw new CommandException(e.Message); } Thread.Sleep(4000); var hash = tx.Hash.ToString(); do { var resultStr = api.Execute("getTransaction", new[] { hash }); dynamic result = JsonConvert.DeserializeObject <TransactionResult>(resultStr); if (result is TransactionResult) { _transactionResults[hash] = (TransactionResult)result; } else if (result is ErrorResult) { var temp = (ErrorResult)result; if (temp.error.Contains("pending")) { Thread.Sleep(1000); continue; } else { throw new CommandException(temp.error); } } else { throw new Exception("Something weird happened with transaction " + hash); } break; } while (true); logger.Success($"Sent transaction with hash {hash}!"); return(Hash.Parse(hash)); }