public void key_test1()
{
BitcoinSecret bsecret1 = Network.Main.CreateBitcoinSecret(strSecret1);
BitcoinSecret bsecret2 = Network.Main.CreateBitcoinSecret(strSecret2);
BitcoinSecret bsecret1C = Network.Main.CreateBitcoinSecret(strSecret1C);
BitcoinSecret bsecret2C = Network.Main.CreateBitcoinSecret(strSecret2C);
Assert.Throws <FormatException>(() => Network.Main.CreateBitcoinSecret(strAddressBad));
Key key1 = bsecret1.PrivateKey;
Assert.True(key1.IsCompressed == false);
Assert.True(bsecret1.Copy(true).PrivateKey.IsCompressed == true);
Assert.True(bsecret1.Copy(true).Copy(false).IsCompressed == false);
Assert.True(bsecret1.Copy(true).Copy(false).ToString() == bsecret1.ToString());
Key key2 = bsecret2.PrivateKey;
Assert.True(key2.IsCompressed == false);
Key key1C = bsecret1C.PrivateKey;
Assert.True(key1C.IsCompressed == true);
Key key2C = bsecret2C.PrivateKey;
Assert.True(key1C.IsCompressed == true);
PubKey pubkey1 = key1.PubKey;
PubKey pubkey2 = key2.PubKey;
PubKey pubkey1C = key1C.PubKey;
PubKey pubkey2C = key2C.PubKey;
Assert.True(addr1.Hash == pubkey1.Hash);
Assert.True(addr2.Hash == pubkey2.Hash);
Assert.True(addr1C.Hash == pubkey1C.Hash);
Assert.True(addr2C.Hash == pubkey2C.Hash);
for (int n = 0; n < 16; n++)
{
string strMsg = String.Format("Very secret message {0}: 11", n);
if (n == 10)
{
//Test one long message
strMsg = String.Join(",", Enumerable.Range(0, 2000).Select(i => i.ToString()).ToArray());
}
uint256 hashMsg = Hashes.Hash256(TestUtils.ToBytes(strMsg));
// normal signatures
ECDSASignature sign1 = null, sign2 = null, sign1C = null, sign2C = null;
List <Task> tasks = new List <Task>();
tasks.Add(Task.Run(() => sign1 = key1.Sign(hashMsg)));
tasks.Add(Task.Run(() => sign2 = key2.Sign(hashMsg)));
tasks.Add(Task.Run(() => sign1C = key1C.Sign(hashMsg)));
tasks.Add(Task.Run(() => sign2C = key2C.Sign(hashMsg)));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1))));
tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2))));
tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1C))));
tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2C))));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1))));
tasks.Add(Task.Run(() => Assert.True(!pubkey1.Verify(hashMsg, sign2))));
tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1C))));
tasks.Add(Task.Run(() => Assert.True(!pubkey1.Verify(hashMsg, sign2C))));
tasks.Add(Task.Run(() => Assert.True(!pubkey2.Verify(hashMsg, sign1))));
tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2))));
tasks.Add(Task.Run(() => Assert.True(!pubkey2.Verify(hashMsg, sign1C))));
tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2C))));
tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1))));
tasks.Add(Task.Run(() => Assert.True(!pubkey1C.Verify(hashMsg, sign2))));
tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1C))));
tasks.Add(Task.Run(() => Assert.True(!pubkey1C.Verify(hashMsg, sign2C))));
tasks.Add(Task.Run(() => Assert.True(!pubkey2C.Verify(hashMsg, sign1))));
tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2))));
tasks.Add(Task.Run(() => Assert.True(!pubkey2C.Verify(hashMsg, sign1C))));
tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2C))));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
// compact signatures (with key recovery)
byte[] csign1 = null, csign2 = null, csign1C = null, csign2C = null;
tasks.Add(Task.Run(() => csign1 = key1.SignCompact(hashMsg)));
tasks.Add(Task.Run(() => csign2 = key2.SignCompact(hashMsg)));
tasks.Add(Task.Run(() => csign1C = key1C.SignCompact(hashMsg)));
tasks.Add(Task.Run(() => csign2C = key2C.SignCompact(hashMsg)));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
PubKey rkey1 = null, rkey2 = null, rkey1C = null, rkey2C = null;
tasks.Add(Task.Run(() => rkey1 = PubKey.RecoverCompact(hashMsg, csign1)));
tasks.Add(Task.Run(() => rkey2 = PubKey.RecoverCompact(hashMsg, csign2)));
tasks.Add(Task.Run(() => rkey1C = PubKey.RecoverCompact(hashMsg, csign1C)));
tasks.Add(Task.Run(() => rkey2C = PubKey.RecoverCompact(hashMsg, csign2C)));
Task.WaitAll(tasks.ToArray());
tasks.Clear();
Assert.True(rkey1.ToHex() == pubkey1.ToHex());
Assert.True(rkey2.ToHex() == pubkey2.ToHex());
Assert.True(rkey1C.ToHex() == pubkey1C.ToHex());
Assert.True(rkey2C.ToHex() == pubkey2C.ToHex());
Assert.True(sign1.IsLowR && sign1.ToDER().Length <= 70);
Assert.True(sign2.IsLowR && sign2.ToDER().Length <= 70);
Assert.True(sign1C.IsLowR && sign1C.ToDER().Length <= 70);
Assert.True(sign2C.IsLowR && sign2C.ToDER().Length <= 70);
}
}
//注册
private void button1_Click(object sender, EventArgs e)
{
label10.Text = mes;
string user = textBox1.Text;
string pwd = textBox2.Text;
string pwd2 = textBox3.Text;
string realname = textBox4.Text;
string realnum = textBox5.Text;
string lovename = textBox6.Text;
byte[] pk = new byte[32];
if (user.Length != 0 && realname.Length != 0 && realnum.Length != 0) //用户名、真实姓名、证件号不能为空
{
if (pwd == pwd2) //确认密码
{
//产生私钥
string AESkey = user + pwd;
while (AESkey.Length < 32)
{
AESkey += "1";
}
string sStr = realnum;
while (sStr.Length < 32)
{
sStr += "3";
}
string s = realname + realnum + lovename;
Console.WriteLine(AESkey);
Console.WriteLine(s);
byte[] p;
p = AES_class.AesEncrypt(s, sStr);
int n = p.Length;
if (n < 32)
{
for (int i = 0; i < n; i++)
{
pk[i] = p[i];
}
for (int i = n; i < 32; i++)
{
pk[i] = 1;
}
}
else if (n > 31)
{
for (int i = 0; i < 32; i++)
{
pk[i] = p[i];
}
}
Key key = new Key(pk);
BitcoinSecret privateKey = key.GetBitcoinSecret(Network.TestNet);
//加密私钥后写入文件
//string path = user+".txt";
string path = user;
string privateKeyStr = "[[[";
privateKeyStr += privateKey.ToString();
privateKeyStr += "]]]";
Console.WriteLine("私钥：" + privateKeyStr);
byte[] APkey;
APkey = AES_class.AesEncrypt(privateKeyStr, AESkey);
Base58Encoder base58Encoder = new Base58Encoder();
string base58Str = base58Encoder.EncodeData(APkey);
Console.WriteLine("写入数据：" + base58Str);
File.WriteAllText(path, base58Str);
//获取地址
PubKey pubKey = privateKey.PubKey;
KeyId pkhash = pubKey.Hash;
BitcoinAddress addres = pkhash.GetAddress(Network.TestNet);
string address = addres.ToString();
MessageBox.Show("注册成功！\n请使用地址：" + address + "前往https://faucet.bitcoincloud.net/网站申领比特币。");
//跳转页面
string pkey = privateKey.ToString();
this.Hide();
Form1 ff = new Form1(pkey);
ff.ShowDialog();
}
else
{
MessageBox.Show("密码输入错误！");
}
}
else
{
MessageBox.Show("请正确输入相关信息！");
}
}
public void base58_keys_valid_gen()
{
var tests = TestCase.read_json("data/base58_keys_valid.json");
tests = tests.Concat(TestCase.read_json("data/base58_keys_valid2.json")).ToArray();
Network network = null;
foreach (var test in tests)
{
string strTest = test.ToString();
if (test.Count < 3) // Allow for extra stuff (useful for comments)
{
Assert.False(true, "Bad test: " + strTest);
continue;
}
string exp_base58string = (string)test[0];
byte[] exp_payload = TestUtils.ParseHex((string)test[1]);
dynamic metadata = test.GetDynamic(2);
bool isPrivkey = (bool)metadata.isPrivkey;
bool isTestnet = (bool)metadata.isTestnet;
if (isTestnet)
{
network = Network.PurpleTest;
}
else
{
network = Network.PurpleMain;
}
if (isPrivkey)
{
bool isCompressed = metadata.isCompressed;
Key key = new Key(exp_payload, fCompressedIn: isCompressed);
BitcoinSecret secret = network.CreateBitcoinSecret(key);
Assert.True(secret.ToString() == exp_base58string, "result mismatch: " + strTest);
}
else
{
string exp_addrType = (string)metadata.addrType;
TxDestination dest;
if (exp_addrType == "pubkey")
{
dest = new KeyId(new uint160(exp_payload));
}
else if (exp_addrType == "script")
{
dest = new ScriptId(new uint160(exp_payload));
}
else if (exp_addrType == "p2wpkh")
{
dest = new WitKeyId(new uint160(exp_payload));
}
else if (exp_addrType == "p2wsh")
{
dest = new WitScriptId(exp_payload);
}
else if (exp_addrType == "none")
{
continue;
}
else
{
Assert.True(false, "Bad addrtype: " + strTest);
continue;
}
try
{
BitcoinAddress addrOut = dest.GetAddress(network);
Assert.True(addrOut.ToString() == exp_base58string, "mismatch: " + strTest);
Assert.True(addrOut.ScriptPubKey == dest.ScriptPubKey);
Assert.True(dest.ScriptPubKey.GetDestination() == dest);
}
catch (ArgumentException)
{
Assert.True(dest.GetType() == typeof(TxDestination));
}
}
}
}
public async Task <Error> GenerateFees(BitcoinSecret sourceSecret, BitcoinSecret destinationSecret, int feeCount)
{
var feeAmount = Settings.Constants.BTCToSathoshiMultiplicationFactor / 100;
var coins = await explorerHelper.GetCoinsForWallet(sourceSecret.GetAddress().ToString(), 10, 0, null, null,
null, true) as GetOrdinaryCoinsForWalletReturnType;
if (coins.Error == null)
{
var selectedCoin = coins.Coins.Where(c => c.Amount >= (ulong)feeCount
* Settings.Constants.BTCToSathoshiMultiplicationFactor).FirstOrDefault();
if (selectedCoin == null)
{
Error retError = new Error();
retError.Message = "Could not find the proper coin to spend.";
return(retError);
}
try
{
TransactionBuilder builder = new TransactionBuilder();
builder.AddKeys(sourceSecret).AddCoins(selectedCoin);
for (int i = 0; i < feeCount; i++)
{
builder.Send(destinationSecret.GetAddress(),
new Money(feeAmount));
}
builder.SetChange(sourceSecret.GetAddress());
builder.SendFees(new Money(feeCount * 100000));
var tx = builder.BuildTransaction(true);
await transactionBroadcaster.BroadcastTransactionToBlockchain(tx.ToHex());
using (BlockchainStateManagerContext context = new BlockchainStateManagerContext())
{
IList <Fee> fees = new List <Fee>();
var txHash = tx.GetHash().ToString();
for (uint i = 0; i < feeCount; i++)
{
if (tx.Outputs[i].Value != feeAmount)
{
continue;
}
fees.Add(new Fee
{
Consumed = false,
TransactionId = txHash,
OutputNumber = (int)i,
Satoshi = (long)feeAmount,
PrivateKey = destinationSecret.ToString(),
Script = tx.Outputs[i].ScriptPubKey.ToString()
});
}
context.Fees.AddRange(fees);
await context.SaveChangesAsync();
}
}
catch (Exception exp)
{
Error retError = new Error();
retError.Message = string.Format("An exception occured {0}.", exp.ToString());
return(retError);
}
return(null); // No error
}
return(coins.Error);
}
private bool HasImportedKey(BitcoinSecret bitcoinSecret)
{
return(_client.ListSecrets().Any(secret => bitcoinSecret.ToString() == secret.ToString()));
}
private static async Task <UnsignedClientCommitmentTransactionResponse> GetOffchainSignedSetup
(string[] privateKeys)
{
var settings = settingsProvider.GetSettings();
var clientPrivateKey = new BitcoinSecret(privateKeys[0]);
var hubPrivateKey = new BitcoinSecret(privateKeys[1]);
var hubSelfRevokKey = new BitcoinSecret(privateKeys[3]);
var multisig = GetMultiSigFromTwoPubKeys(clientPrivateKey.PubKey, hubPrivateKey.PubKey);
var coloredRPC = GetColoredRPCClient(settings as IBlockchainStateManagerSettings);
BitcoinColoredAddress[] addresses = new BitcoinColoredAddress[3];
addresses[0] = clientPrivateKey.PubKey.WitHash.ScriptPubKey.GetScriptAddress(settings.Network).ToColoredAddress(); // c74X52L89exgnqwrFmeKzZTAxi49sLxqoNS
addresses[1] = hubPrivateKey.PubKey.WitHash.ScriptPubKey.GetScriptAddress(settings.Network).ToColoredAddress(); // c7Acx1CTvvwPr9kEa91roJDeNLjB1evkXWG
addresses[2] = BitcoinAddress.Create(multisig.SegwitMultiSigAddress).ToColoredAddress(); // c7GuJuSS5aNg9s791bDk6RgSpYCge3kaiHn
long[] valuesToSend = new long[3];
valuesToSend[0] = 100 * DESIREDASSETMULTIPLICATIONFACTOR;
valuesToSend[1] = 100 * DESIREDASSETMULTIPLICATIONFACTOR;
valuesToSend[2] = 85 * DESIREDASSETMULTIPLICATIONFACTOR;
uint256[] txIds = new uint256[3];
for (int i = 0; i < 3; i++)
{
if (ASSET.ToLower().Trim() == "btc")
{
txIds[i] = await daemonHelper.SendBitcoinToDestination(addresses[i].Address, valuesToSend[i]);
}
else
{
txIds[i] = await coloredRPC.IssueAssetAsync(Constants.USDAssetPrivateKey.GetAddress(), addresses[i], valuesToSend[i]);
}
}
var bitcoinRPCCLient = GetRPCClient(settings as IBlockchainStateManagerSettings);
var blkIds = await bitcoinRPCCLient.GenerateBlocksAsync(1);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasBlockIndexed, blkIds);
for (int i = 0; i < txIds.Count(); i++)
{
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasTransactionIndexed, new string[] { txIds[i].ToString() });
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed(blockchainExplorerHelper.HasBalanceIndexed,
new string[] { txIds[i].ToString() }, addresses[i].Address.ToString());
}
var unsignedChannelsetup = await offchainHelper.GenerateUnsignedChannelSetupTransaction
(clientPrivateKey.PubKey, 10, hubPrivateKey.PubKey, 10, ASSET, 7);
var clientSignedTx = await Helper.SignTransactionWorker(new TransactionSignRequest
{
TransactionToSign = unsignedChannelsetup.UnsigndTransaction,
PrivateKey = clientPrivateKey.ToString()
});
var unsignedResp = await offchainHelper.CreateUnsignedClientCommitmentTransaction
(unsignedChannelsetup.UnsigndTransaction, clientSignedTx, 30, 75, clientPrivateKey.PubKey,
hubPrivateKey.ToString(), ASSET, hubSelfRevokKey.PubKey, 144);
return(unsignedResp);
}
public static async Task <bool> PutBlockchainInAKnownState(string[] privateKeys)
{
var settings = settingsProvider.GetSettings();
try
{
var clientPrivateKey = new BitcoinSecret(privateKeys[0]);
var hubPrivateKey = new BitcoinSecret(privateKeys[1]);
var clientSelfRevokeKey = new BitcoinSecret(privateKeys[2]);
var hubSelfRevokKey = new BitcoinSecret(privateKeys[3]);
var feeSourcePrivateKey = new BitcoinSecret(new Key(), settings.Network);
var feeDestinationPrivateKey = new BitcoinSecret(new Key(), settings.Network);
uint feeCount = 100;
AssetDefinition usdAsset = null;
foreach (var item in (settings as IBlockchainStateManagerSettings).Assets)
{
if (item.Name == "TestExchangeUSD")
{
usdAsset = item;
break;
}
}
if (!await StartRequiredJobs(true))
{
return(false);
}
var bitcoinRPCCLient = GetRPCClient(settings as IBlockchainStateManagerSettings);
IEnumerable <string> blkIds = null;
for (int i = 0; i < 201; i++)
{
var blkCount = 1;
blkIds = await bitcoinRPCCLient.GenerateBlocksAsync(blkCount);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasBlockIndexed, blkIds);
}
/*
* for (int i = 0; i < 11; i++)
* {
* var blkCount = 20;
* if (i == 10)
* {
* blkCount = 1;
* }
*
* blkIds = await bitcoinRPCCLient.GenerateBlocksAsync(blkCount);
* await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
* (blockchainExplorerHelper.HasBlockIndexed, blkIds);
* }
*/
await bitcoinRPCCLient.ImportPrivKeyAsync(new BitcoinSecret(usdAsset.PrivateKey));
var txId = await bitcoinRPCCLient.SendToAddressAsync(new BitcoinSecret(usdAsset.PrivateKey).GetAddress(),
new Money(100 * Constants.BTCToSathoshiMultiplicationFactor));
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasTransactionIndexed, new string[] { txId.ToString() });
txId = await bitcoinRPCCLient.SendToAddressAsync(feeSourcePrivateKey.GetAddress(),
new Money((feeCount + 1) * Constants.BTCToSathoshiMultiplicationFactor));
blkIds = await bitcoinRPCCLient.GenerateBlocksAsync(1);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasBlockIndexed, blkIds);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasTransactionIndexed, new string[] { txId.ToString() });
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasBalanceIndexed, new string[] { txId.ToString() }, feeSourcePrivateKey.GetAddress().ToString());
var error = await feeManager.GenerateFees(feeSourcePrivateKey, feeDestinationPrivateKey, (int)feeCount);
if (error != null)
{
return(false);
}
var signedResp = await GetOffchainSignedSetup(privateKeys);
await transactionBroadcaster.BroadcastTransactionToBlockchain
(signedResp.FullySignedSetupTransaction);
await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
(blockchainExplorerHelper.HasTransactionIndexed, new string[] { new Transaction(signedResp.FullySignedSetupTransaction).GetHash().ToString() });
/*
* // Not used
* var unsignedCommitment = await offchainHelper.CreateUnsignedCommitmentTransactions(signedResp.FullySignedSetupTransaction, clientPrivateKey.PubKey,
* hubPrivateKey.PubKey, 40, 65, ASSET, hubSelfRevokKey.PubKey, 10, true);
*/
var clientSignedCommitment = await Helper.SignTransactionWorker(new TransactionSignRequest
{
TransactionToSign = signedResp.UnsignedClientCommitment0,
PrivateKey = clientPrivateKey.ToString()
}, SigHash.All | SigHash.AnyoneCanPay);
var commitmentToLog = clientSignedCommitment;
/*
* var commitmentSpendingResp = await offchainHelper.CreateCommitmentSpendingTransactionForTimeActivatePart(txSendingResult.ToHex(), hubPrivateKey.ToString(),
* clientPrivateKey.PubKey, hubPrivateKey.PubKey, "TestExchangeUSD", hubSelfRevokKey.PubKey, 144, true);
*/
var commitmentSpendingResp = await offchainHelper.CreateCommitmentSpendingTransactionForMultisigPart(clientSignedCommitment, clientPrivateKey.PubKey, hubPrivateKey.PubKey,
ASSET, 75, hubSelfRevokKey.PubKey, 144, true, clientPrivateKey, hubSelfRevokKey);
// Fee is now directly paid from output for bitcoin
// txSendingResult = await AddEnoughFeesToTransaction
// (new Transaction(commitmentSpendingResp.TransactionHex));
var hubSignedCommitment = await Helper.SignTransactionWorker(new TransactionSignRequest
{
TransactionToSign = clientSignedCommitment,
PrivateKey = hubPrivateKey.ToString()
}, SigHash.All | SigHash.AnyoneCanPay);
// var txSendingResult = await AddEnoughFeesToTransaction
// (new Transaction(hubSignedCommitment));
//var txSendingResult = new Transaction(hubSignedCommitment);
//await transactionBroadcaster.BroadcastTransactionToBlockchain
// (txSendingResult.ToHex());
//await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
// (blockchainExplorerHelper.HasTransactionIndexed, new string[] { txSendingResult.GetHash().ToString() });
//await blockchainExplorerHelper.WaitUntillBlockchainExplorerHasIndexed
// (blockchainExplorerHelper.HasBalanceIndexedZeroConfirmation, new string[] { txSendingResult.GetHash().ToString() },
// clientPrivateKey.PubKey.WitHash.ScriptPubKey.GetScriptAddress(settings.Network).ToString());
// bool v = await VerifyTransaction(txSendingResult);
var punishmentToLog = commitmentSpendingResp.TransactionHex;
using (StreamWriter writer = new StreamWriter("log.txt"))
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("HubUnsignedCommitment:");
builder.AppendLine(commitmentToLog);
builder.AppendLine("HubSignedCommitment");
builder.AppendLine(hubSignedCommitment);
builder.AppendLine("Punishment:");
builder.AppendLine(punishmentToLog);
await writer.WriteAsync(builder.ToString());
}
return(true);
}
catch (Exception exp)
{
throw exp;
}
}
public void key_test1()
{
BitcoinSecret bsecret1 = Network.Main.CreateBitcoinSecret(strSecret1);
BitcoinSecret bsecret2 = Network.Main.CreateBitcoinSecret(strSecret2);
BitcoinSecret bsecret1C = Network.Main.CreateBitcoinSecret(strSecret1C);
BitcoinSecret bsecret2C = Network.Main.CreateBitcoinSecret(strSecret2C);
Assert.Throws <FormatException>(() => Network.Main.CreateBitcoinSecret(strAddressBad));
Key key1 = bsecret1.PrivateKey;
Assert.True(key1.IsCompressed == false);
Assert.True(bsecret1.Copy(true).PrivateKey.IsCompressed == true);
Assert.True(bsecret1.Copy(true).Copy(false).IsCompressed == false);
Assert.True(bsecret1.Copy(true).Copy(false).ToString() == bsecret1.ToString());
Key key2 = bsecret2.PrivateKey;
Assert.True(key2.IsCompressed == false);
Key key1C = bsecret1C.PrivateKey;
Assert.True(key1C.IsCompressed == true);
Key key2C = bsecret2C.PrivateKey;
Assert.True(key1C.IsCompressed == true);
PubKey pubkey1 = key1.PubKey;
PubKey pubkey2 = key2.PubKey;
PubKey pubkey1C = key1C.PubKey;
PubKey pubkey2C = key2C.PubKey;
Assert.True(addr1.Hash == pubkey1.Hash);
Assert.True(addr2.Hash == pubkey2.Hash);
Assert.True(addr1C.Hash == pubkey1C.Hash);
Assert.True(addr2C.Hash == pubkey2C.Hash);
for (int n = 0; n < 16; n++)
{
string strMsg = String.Format("Very secret message {0}: 11", n);
if (n == 10)
{
//Test one long message
strMsg = String.Join(",", Enumerable.Range(0, 2000).Select(i => i.ToString()).ToArray());
}
uint256 hashMsg = Hashes.DoubleSHA256(TestUtils.ToBytes(strMsg));
// normal signatures
ECDSASignature sign1 = null, sign2 = null, sign1C = null, sign2C = null;
List <Task> tasks = new List <Task>();
sign1 = key1.Sign(hashMsg);
sign2 = key2.Sign(hashMsg);
sign1C = key1C.Sign(hashMsg);
sign2C = key2C.Sign(hashMsg);
for (int i = 0; i < 30; i++)
{
Assert.True(pubkey1.Verify(hashMsg, sign1));
Assert.True(pubkey2.Verify(hashMsg, sign2));
Assert.True(pubkey1C.Verify(hashMsg, sign1C));
Assert.True(pubkey2C.Verify(hashMsg, sign2C));
Assert.True(pubkey1.Verify(hashMsg, sign1));
Assert.True(!pubkey1.Verify(hashMsg, sign2));
Assert.True(pubkey1.Verify(hashMsg, sign1C));
Assert.True(!pubkey1.Verify(hashMsg, sign2C));
Assert.True(!pubkey2.Verify(hashMsg, sign1));
Assert.True(pubkey2.Verify(hashMsg, sign2));
Assert.True(!pubkey2.Verify(hashMsg, sign1C));
Assert.True(pubkey2.Verify(hashMsg, sign2C));
Assert.True(pubkey1C.Verify(hashMsg, sign1));
Assert.True(!pubkey1C.Verify(hashMsg, sign2));
Assert.True(pubkey1C.Verify(hashMsg, sign1C));
Assert.True(!pubkey1C.Verify(hashMsg, sign2C));
Assert.True(!pubkey2C.Verify(hashMsg, sign1));
Assert.True(pubkey2C.Verify(hashMsg, sign2));
Assert.True(!pubkey2C.Verify(hashMsg, sign1C));
Assert.True(pubkey2C.Verify(hashMsg, sign2C));
}
}
}
