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));
}
