private void RunTest(TestVector test)
{
var seed = TestUtils.ParseHex(test.strHexMaster);
ExtKey key = new ExtKey(seed);
ExtPubKey pubkey = key.Neuter();
foreach (TestDerivation derive in test.vDerive)
{
byte[] data = key.ToBytes();
Assert.Equal(74, data.Length);
data = pubkey.ToBytes();
Assert.Equal(74, data.Length);
// Test private key
BitcoinExtKey b58key = Network.PurpleMain.CreateBitcoinExtKey(key);
Assert.True(b58key.ToString() == derive.prv);
// Test public key
BitcoinExtPubKey b58pubkey = Network.PurpleMain.CreateBitcoinExtPubKey(pubkey);
Assert.True(b58pubkey.ToString() == derive.pub);
// Derive new keys
ExtKey keyNew = key.Derive(derive.nChild);
ExtPubKey pubkeyNew = keyNew.Neuter();
if (!((derive.nChild & 0x80000000) != 0))
{
// Compare with public derivation
ExtPubKey pubkeyNew2 = pubkey.Derive(derive.nChild);
Assert.True(pubkeyNew == pubkeyNew2);
}
key = keyNew;
pubkey = pubkeyNew;
}
}
//https://github.com/libbitcoin/libbitcoin/blob/master/test/stealth.cpp
public void BitFieldCorrectlyMatchData()
{
var bit = (uint)1358086238;
var o = new BitField(bit, 32);
var tests = new[]
{
new
{
Encoded = (uint)0x691cf48b,
BitCount = 27,
Data = "8bf42c79",
Match = false
},
new
{
Encoded = (uint)0x691cf48b,
BitCount = 27,
//Data miss match (1 instead of 2)
Data = "8bf41c79",
Match = true
}
};
foreach (var test in tests)
{
BitField field = new BitField(test.Encoded, test.BitCount);
Assert.Equal(test.Match, field.Match(Utils.ToUInt32(TestUtils.ParseHex(test.Data), true)));
}
}
//https://wiki.unsystem.net/index.php/DarkWallet/Stealth#Bitfield_value
public void BitFieldCorrectlyInterpreted()
{
var tests = new[]
{
new
{
Encoded = (uint)1763505291,
BitCount = 32,
Raw = "8bf41c69"
},
new
{
Encoded = (uint)1,
BitCount = 8,
Raw = "0100"
},
new
{
Encoded = (uint)1,
BitCount = 7,
Raw = "01"
}
};
foreach (var test in tests)
{
var bitField = new BitField(test.Encoded, test.BitCount);
Assert.Equal(TestUtils.ParseHex(test.Raw), bitField.GetRawForm());
Assert.Equal(test.Encoded, bitField.GetEncodedForm());
bitField = new BitField(TestUtils.ParseHex(test.Raw), test.BitCount);
Assert.Equal(test.Encoded, bitField.GetEncodedForm());
Assert.Equal(TestUtils.ParseHex(test.Raw), bitField.GetRawForm());
}
}
private static void PlaySplit()
{
var scan = new Key(TestUtils.ParseHex("cc411aab02edcd3bccf484a9ba5280d4a774e6f81eac8ebec9cb1c2e8f73020a"));
var addr = new BitcoinStealthAddress("waPYjXyrTrvXjZHmMGdqs9YTegpRDpx97H5G3xqLehkgyrrZKsxGCmnwKexpZjXTCskUWwYywdUvrZK7L2vejeVZSYHVns61gm8VfU", Network.TestNet);
var sender = new BitcoinSecret("privatekey", Network.TestNet);
var receiver = new BitcoinSecret("privatekey", Network.TestNet);
MakePayment(sender, receiver, Money.Parse("1.00"));
}
public void CanParseStealthAddress()
{
var tests = new[]
{
//Test vector created with sx
//sx stealth-newkey -> ScanSecret,SpendSecret,StealthAddress
//sx stealth-show-addr StealthAddress -> ScanPubKey,SpendPubKey,RequiredSignature...
new
{
ScanSecret = "9ac9fdee7c2c19611bcbed8959e1c61d00cdc27cf17bb50a1f4d29db7f953632",
SpendSecrets = new[] {
"4e2fa767cc241c3fa4c512d572b2758a3960a06d374f2c819fe409b161d72ad4"
},
StealthAddress = "vJmsmwE8cVt9ytJxBuY2jayh8RAfvpG42CyNVYpeVZAkHaiwASobUEzskpXMwbH1TZNBLoxWWYem5WuZewTL8xz3upJ75zKcdVmTfg",
ScanPubKey = "021ce89be99a229d123e8bc13ffbcb66722d6200bbeb1d90ddddbf97df82ed2672",
SpendPubKeys = new[]
{
"03c197525241d3d70bbf33bb2b54d41e6b9595a92a2c6b7bf7157727c017f0154a"
},
RequiredSignature = 1,
Options = 0,
PrefixLength = 0,
PrefixValue = "",
}
};
foreach (var test in tests)
{
var scanSecret = new Key(TestUtils.ParseHex(test.ScanSecret));
AssertEx.CollectionEquals(scanSecret.PubKey.ToBytes(), TestUtils.ParseHex(test.ScanPubKey));
var stealth = new BitcoinStealthAddress(test.StealthAddress, Network.Main);
Assert.Equal(test.RequiredSignature, stealth.SignatureCount);
Assert.Equal(test.PrefixLength, stealth.Prefix.BitCount);
AssertEx.CollectionEquals(stealth.Prefix.GetRawForm(), TestUtils.ParseHex(test.PrefixValue));
Assert.Equal(test.Options, stealth.Options);
AssertEx.CollectionEquals(stealth.ScanPubKey.ToBytes(),
TestUtils.ParseHex(test.ScanPubKey));
for (int i = 0; i < test.SpendPubKeys.Length; i++)
{
AssertEx.CollectionEquals(stealth.SpendPubKeys[i].ToBytes(),
TestUtils.ParseHex(test.SpendPubKeys[i]));
var spendSecret = new Key(TestUtils.ParseHex(test.SpendSecrets[i]));
AssertEx.CollectionEquals(stealth.SpendPubKeys[i].ToBytes(), TestUtils.ParseHex(test.SpendPubKeys[i]));
}
}
}
private Key AssertKeys(string key, string pub)
{
if (key == null)
{
return(null);
}
Key k = new Key(TestUtils.ParseHex(key));
if (pub != null)
{
PubKey p = new PubKey(TestUtils.ParseHex(pub));
AssertEx.Equal(k.PubKey.ToBytes(), p.ToBytes());
}
return(k);
}
public void CanCreateAssetAddress()
{
var key = new Key(TestUtils.ParseHex("18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725"));
var address = key.PubKey.Decompress().GetAddress(Network.Main);
Assert.Equal("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM", address.ToString());
Script script = Script.FromBitcoinAddress(address);
Assert.Equal("OP_DUP OP_HASH160 010966776006953D5567439E5E39F86A0D273BEE OP_EQUALVERIFY OP_CHECKSIG", script.ToString().ToUpper());
var scriptAddress = script.GetAddress(Network.Main);
Assert.Equal("36hBrMeUfevFPZdY2iYSHVaP9jdLd9Np4R", scriptAddress.ToString());
}
public void CanParseAlertAndChangeUpdatePayloadAndSignature()
{
var alertStr = "73010000003766404f00000000b305434f00000000f2030000f1030000001027000048ee00000064000000004653656520626974636f696e2e6f72672f666562323020696620796f7520686176652074726f75626c6520636f6e6e656374696e67206166746572203230204665627275617279004730450221008389df45f0703f39ec8c1cc42c13810ffcae14995bb648340219e353b63b53eb022009ec65e1c1aaeec1fd334c6b684bde2b3f573060d5b70c3a46723326e4e8a4f1";
AlertPayload alert = new AlertPayload();
alert.FromBytes(TestUtils.ParseHex(alertStr));
Assert.True(alert.CheckSignature(Network.Main));
Assert.Equal("See bitcoin.org/feb20 if you have trouble connecting after 20 February", alert.StatusBar);
alert.StatusBar = "Changing...";
Assert.True(alert.CheckSignature(Network.Main));
alert.UpdatePayload();
Assert.False(alert.CheckSignature(Network.Main));
Key key = new Key();
alert.UpdateSignature(key);
Assert.True(alert.CheckSignature(key.PubKey));
}
//https://en.bitcoin.it/wiki/Difficulty
public void CanReadConvertTargetToDifficulty()
{
var packed = new Target(TestUtils.ParseHex("1b0404cb"));
var unpacked = new Target(uint256.Parse("00000000000404CB000000000000000000000000000000000000000000000000"));
Assert.Equal(packed, unpacked);
Assert.Equal(packed, new Target(0x1b0404cb));
packed = new Target(TestUtils.ParseHex("1b8404cb"));
Assert.True(packed.ToBigInteger().CompareTo(BigInteger.Zero) < 0);
Assert.Equal(packed, new Target(0x1b8404cb));
packed = new Target(TestUtils.ParseHex("1d00ffff"));
Assert.Equal(1, packed.Difficulty);
Assert.Equal(Target.Difficulty1, packed);
packed = new Target(TestUtils.ParseHex("1b0404cb"));
Assert.Equal(16307.420938523983D, packed.Difficulty, "420938523983".Length);
Assert.Equal(packed, new Target((uint)0x1b0404cb));
Assert.Equal((uint)packed, (uint)0x1b0404cb);
packed = new Target((uint)0x1b0404d1);
Assert.Equal(16307.04943863739, packed.Difficulty, "420938523983".Length);
packed = new Target(0x1d00ffff);
Assert.Equal((uint)packed, (uint)0x1d00ffff);
//Check http://blockchain.info/block-index/392672/0000000000000000511e193e22d2dfc02aea8037988f0c58e9834f4550e97702
packed = new Target(419470732);
Assert.Equal(6978842649.592383, packed.Difficulty, "592383".Length);
Assert.Equal((uint)packed, (uint)419470732);
Assert.True(uint256.Parse("0x0000000000000000511e193e22d2dfc02aea8037988f0c58e9834f4550e97702") < packed.ToUInt256());
//Check http://blockchain.info/block-index/394713/0000000000000000729a4a7e084c90f932d038c407a6535a51dfecdfba1c8906
Assert.True(uint256.Parse("0x0000000000000000729a4a7e084c90f932d038c407a6535a51dfecdfba1c8906 ") < new Target(419470732).ToUInt256());
var genesis = Network.Main.GetGenesis();
Assert.True(genesis.GetHash() < genesis.Header.Bits.ToUInt256());
Assert.True(Target.Difficulty1 == Target.Difficulty1);
}
public void CanCreateAssetAddress()
{
//The issuer first generates a private key: 18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725.
var key = new Key(TestUtils.ParseHex("18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725"));
//He calculates the corresponding address: 16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM.
var address = key.PubKey.Decompress().GetAddress(Network.Main);
Assert.Equal("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM", address.ToString());
//Next, he builds the Pay-to-PubKey-Hash script associated to that address: OP_DUP OP_HASH160 010966776006953D5567439E5E39F86A0D273BEE OP_EQUALVERIFY OP_CHECKSIG
Script script = Script.CreateFromDestinationAddress(address);
Assert.Equal("OP_DUP OP_HASH160 010966776006953D5567439E5E39F86A0D273BEE OP_EQUALVERIFY OP_CHECKSIG", script.ToString().ToUpper());
//36hBrMeUfevFPZdY2iYSHVaP9jdLd9Np4R.
var scriptAddress = script.GetScriptAddress(Network.Main);
Assert.Equal("36hBrMeUfevFPZdY2iYSHVaP9jdLd9Np4R", scriptAddress.ToString());
Assert.Equal("36hBrMeUfevFPZdY2iYSHVaP9jdLd9Np4R", key.PubKey.Decompress().GetAddress(Network.Main).GetScriptAddress().ToString());
}
//https://github.com/libbitcoin/libbitcoin/blob/master/test/stealth.cpp
public void BitFieldCanFetchTransaction()
{
var tests = new[]
{
new
{
Encoded = "deadbeef",
BitCount = 5,
Transaction = "0100000001bd365d65c6eeee2d3ae29c6e1b0fb22f70f0135220eac1273c92a13b6039ecdf000000006b48304502202551626a52a088ea585f2aaa8afe1c1b7bc52ea8e577e149f20f0f5f2fc54485022100913643c6a1e54b5284d1c108519d9243213373256ff95ab6c7e3d162175c9e28012102881c1427e826f230246197f7f693f1c923ad2afea1dad901d1c870f7e310c895ffffffff020000000000000000286a2606ab3099ae0359222b4a2dd9a21ebd70331794fb05b0bd605bd9660fdf895906b1a227edcbec306c3402000000001976a9142f62432f367dc3cf67e68f814cc2a3ed5b2e8cec88ac00000000",
}
, new
{
Encoded = "deadbeef",
BitCount = 5,
Transaction = "01000000028d8d968818e464db9dc876eb4edd59e62913d849603ba10afe033159b55652dc010000006b483045022100992e7ce4516cdabffae823557f5854c6ca7a424cc2fe7a9b94f439ecca839f84022025b871cf499f7b0eebcf751a83e7ffe9473b6c5227f95d9989ef8e98937112760121038795ff1d07ef7092e03d612f187d1281705b36d0c11ecf4b11167beb7efc3437ffffffff723372d920d8eaa6bd1fe6ec5adaf913b6d8a48655acded49a3f09191cdf9f3a010000006a47304402206f6ca054242fe5b410d743ae238049799eccdd88637d555ad48d8da1a854bd0802201b13217d0a6a7cf3467074aa8964f3f365541304142503d91813baa0117d1a8101210258cedc6e590493838c612a394d53ffbb283638f9d1d49e1c571b15a885f405d9ffffffff05f0874b00000000001976a914cd08dcd94ba88488b4c02c82fc11fc63fee4e30c88acc0e1e400000000001976a9148784cbfe99e86135d40d276c58fcbbf37af1b48e88ac0000000000000000286a260689d0267d021cc402cf764f2c88138028b6d5c0f06d5caa34edffc1d2286048f0162756ebf1f0874b00000000001976a914923d77bbdd3d29dd4844a51629514bac9e8a2c4d88aca30c0000000000001976a9143aaa9db7a3fbc5dcc9d121a157bf63aaaee9d8f588ac00000000",
},
new
{
Encoded = "deadbeef",
BitCount = 5,
Transaction = "010000000288b6952f8357b5a8271f6c0608ea779549bf0a9ae72213ce433f7a9c90190be6000000006b4830450221008b1b7369d7bf8a1dd99e6a260ef969840d633ba81fc379bf4f5469afd3b288e2022077e21dd12c1d8b2a4ab2e58fb0113b9e3bb77db4439483f7a8311cac3ad6ce9a012102b0c2eb0cc505a4c9fb62df8a7fcdcc00ddab43ff5752ebc51a0dae11fbfb0648ffffffff4ca2f8960e17b56e690739158994ed23427ffc08445ba3223edacb322db12d4b000000006b483045022100f94d50d846d85a545693574f9e1a680a858f085257c827cd8b211df8d27c558202201bca0407ad67960937999a88c95e52417442703a16036bbe55f071cdff804f69012102884d0c845bff3158e88033bce236cdbfeadba0a7e7381258379612f355681d6dffffffff052f750000000000001976a914a34a179dc97cbb84992d2960ee240b56f1b2ae3088acbca15400000000001976a914139e314f94a8e4fc2864ef2544e7640ba033725b88ac0000000000000000286a26061d6b629c024c7daf682da4afd61aadf401fae316a265c3244d912b375a75b55551d52a583f2f750000000000001976a9142888cb9f0b0f489106bc13f56fdd2ceec1b6883788ac51c30000000000001976a91404316e7db781481d1419feda2c8d7fa9f7b68a6e88ac00000000",
},
};
foreach (var test in tests)
{
var field = new BitField(TestUtils.ParseHex(test.Encoded), test.BitCount);
Transaction transaction = new Transaction();
transaction.FromBytes(TestUtils.ParseHex(test.Transaction));
var stealthOutput = field.GetPayments(transaction).FirstOrDefault();
Assert.NotNull(stealthOutput);
Assert.True(field.Match(stealthOutput.Metadata.BitField));
}
}
public void CanCreateAssetAddress()
{
//The issuer first generates a private key: 18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725.
var key = new Key(TestUtils.ParseHex("18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725"));
//He calculates the corresponding address: 16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM.
BitcoinPubKeyAddress address = key.PubKey.Decompress().GetAddress(this.networkMain);
Assert.Equal("16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM", address.ToString());
//Next, he builds the Pay-to-PubKey-Hash script associated to that address: OP_DUP OP_HASH160 010966776006953D5567439E5E39F86A0D273BEE OP_EQUALVERIFY OP_CHECKSIG
Script script = address.ScriptPubKey;
Assert.Equal("OP_DUP OP_HASH160 010966776006953D5567439E5E39F86A0D273BEE OP_EQUALVERIFY OP_CHECKSIG", script.ToString().ToUpper());
BitcoinScriptAddress oo = script.GetScriptAddress(this.networkMain);
//The script is hashed: 36e0ea8e93eaa0285d641305f4c81e563aa570a2.
Assert.Equal("36e0ea8e93eaa0285d641305f4c81e563aa570a2", script.Hash.ToString());
Assert.Equal("36e0ea8e93eaa0285d641305f4c81e563aa570a2", key.PubKey.Decompress().Hash.ScriptPubKey.Hash.ToString());
//Finally, the hash is converted to a base 58 string with checksum using version byte 23: ALn3aK1fSuG27N96UGYB1kUYUpGKRhBuBC.
Assert.Equal("ALn3aK1fSuG27N96UGYB1kUYUpGKRhBuBC", script.Hash.ToAssetId().GetWif(this.networkMain).ToString());
}
private static void PlaySplit()
{
var scan = new Key(TestUtils.ParseHex("cc411aab02edcd3bccf484a9ba5280d4a774e6f81eac8ebec9cb1c2e8f73020a"));
var addr = new BitcoinStealthAddress("waPYjXyrTrvXjZHmMGdqs9YTegpRDpx97H5G3xqLehkgyrrZKsxGCmnwKexpZjXTCskUWwYywdUvrZK7L2vejeVZSYHVns61gm8VfU", Network.TestNet);
var sender = new BitcoinSecret("cRjSUV1LqN2F8MsGnLE2JKfCP75kbWGFRroNQeXHC429jqVFgmW3", Network.TestNet);
var tx = new Transaction();
tx.Version = 1;
RPCClient client = RPCClientTests.CreateRPCClient();
var coins = client.ListUnspent();
foreach (var unspent in coins)
{
tx.Inputs.Add(new TxIn(unspent.OutPoint));
}
var amount = coins.Select(c => c.Amount).Sum();
var perOut = (long)(amount.Satoshi / 13);
while (amount > 0)
{
var toSend = Math.Min(perOut, (long)amount);
amount -= toSend;
var tout = new TxOut(toSend, sender.GetAddress());
if (!tout.IsDust)
{
tx.Outputs.Add(tout);
}
}
tx.SignAll(sender);
client.SendRawTransaction(tx);
}
//Copied from https://en.bitcoin.it/wiki/Protocol_specification (19/04/2014)
public void CanParseMessages()
{
TimeZoneInfo EST;
try
{
EST = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
}
catch (TimeZoneNotFoundException)
{
EST = TimeZoneInfo.FindSystemTimeZoneById("America/New_York");
}
var tests = new[]
{
new
{
Version = 209U,
Message = "f9beb4d976657273696f6e0000000000550000009c7c00000100000000000000e615104d00000000010000000000000000000000000000000000ffff0a000001208d010000000000000000000000000000000000ffff0a000002208ddd9d202c3ab457130055810100",
Test = new Action <object>(o =>
{
var version = (VersionPayload)o;
Assert.Equal((ulong)0x1357B43A2C209DDD, version.Nonce);
Assert.Equal("", version.UserAgent);
Assert.Equal("::ffff:10.0.0.2", version.AddressFrom.Address.ToString());
Assert.Equal(8333, version.AddressFrom.Port);
Assert.Equal(0x00018155, version.StartHeight);
Assert.Equal <uint>(31900, version.Version);
})
},
new
{
Version = 60002U,
Message = "f9beb4d976657273696f6e000000000064000000358d493262ea0000010000000000000011b2d05000000000010000000000000000000000000000000000ffff000000000000000000000000000000000000000000000000ffff0000000000003b2eb35d8ce617650f2f5361746f7368693a302e372e322fc03e0300",
Test = new Action <object>(o =>
{
var version = (VersionPayload)o;
Assert.Equal("/Satoshi:0.7.2/", version.UserAgent);
Assert.Equal(0x00033EC0, version.StartHeight);
})
},
new
{
Version = 70012U,
Message = "f9beb4d976657261636b000000000000000000005df6e0e2",
Test = new Action <object>(o =>
{
var verack = (VerAckPayload)o;
})
},
new
{
Version = 60002U,
Message = "f9beb4d96164647200000000000000001f000000ed52399b01e215104d010000000000000000000000000000000000ffff0a000001208d",
Test = new Action <object>(o =>
{
var addr = (AddrPayload)o;
Assert.Single(addr.Addresses);
//"Mon Dec 20 21:50:10 EST 2010"
var date = TimeZoneInfo.ConvertTime(addr.Addresses[0].Time, EST);
Assert.Equal(20, date.Day);
Assert.Equal(12, date.Month);
Assert.Equal(2010, date.Year);
Assert.Equal(21, date.Hour);
})
},
};
foreach (var test in tests)
{
var message = Network.Main.ParseMessage(TestUtils.ParseHex(test.Message), test.Version);
test.Test(message.Payload);
var bytes = message.ToBytes(test.Version);
var old = message;
message = new Message();
message.FromBytes(bytes, test.Version);
test.Test(message.Payload);
Assert.Equal(test.Message, Encoders.Hex.EncodeData(message.ToBytes(test.Version)));
}
}
public void base58_keys_valid_parse()
{
TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataFolder("base58_keys_valid.json"));
Network network;
foreach (TestCase test in tests)
{
string strTest = test.ToString();
if (test.Count < 3) // Allow for extra stuff (useful for comments)
{
Assert.True(false, "Bad test " + strTest);
continue;
}
string exp_base58string = (string)test[0];
byte[] exp_payload = TestUtils.ParseHex((string)test[1]);
//const Object &metadata = test[2].get_obj();
bool isPrivkey = (bool)test.GetDynamic(2).isPrivkey;
bool isTestnet = (bool)test.GetDynamic(2).isTestnet;
if (isTestnet)
{
network = KnownNetworks.TestNet;
}
else
{
network = KnownNetworks.Main;
}
if (isPrivkey)
{
bool isCompressed = (bool)test.GetDynamic(2).isCompressed;
// Must be valid private key
// Note: CBitcoinSecret::SetString tests isValid, whereas CBitcoinAddress does not!
BitcoinSecret secret = network.CreateBitcoinSecret(exp_base58string);
//If not valid exception would throw
Key privkey = secret.PrivateKey;
Assert.True(privkey.IsCompressed == isCompressed, "compressed mismatch:" + strTest);
Assert.True(Utils.ArrayEqual(privkey.ToBytes(), exp_payload), "key mismatch:" + strTest);
// Private key must be invalid public key
Assert.Throws <FormatException>(() => network.CreateBitcoinAddress(exp_base58string));
}
else
{
string exp_addrType = (string)test.GetDynamic(2).addrType; // "script" or "pubkey"
// Must be valid public key
BitcoinAddress addr = network.CreateBitcoinAddress(exp_base58string);
Assert.True((addr is BitcoinScriptAddress) == (exp_addrType == "script"), "isScript mismatch" + strTest);
if (exp_addrType == "script")
{
Assert.True(addr.GetType() == typeof(BitcoinScriptAddress));
}
if (exp_addrType == "pubkey")
{
Assert.True(addr.GetType() == typeof(BitcoinPubKeyAddress));
}
Assert.Throws <FormatException>(() => network.CreateBitcoinSecret(exp_base58string));
}
}
}
public void base58_keys_valid_gen()
{
TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataFolder("base58_keys_valid.json"));
tests = tests.Concat(TestCase.read_json(TestDataLocations.GetFileFromDataFolder("base58_keys_valid2.json"))).ToArray();
Network network = null;
foreach (TestCase 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 = KnownNetworks.TestNet;
}
else
{
network = KnownNetworks.Main;
}
if (isPrivkey)
{
bool isCompressed = metadata.isCompressed;
var 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(KnownNetworks.Main) == dest);
}
catch (ArgumentException)
{
Assert.True(dest.GetType() == typeof(TxDestination));
}
}
}
}
//Copied from https://en.bitcoin.it/wiki/Protocol_specification (19/04/2014)
public void CanParseMessages()
{
if (pos_RPCClientTests.noClient)
{
return;
}
var EST = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
var tests = new[]
{
new
{
Version = ProtocolVersion.INIT_PROTO_VERSION,
Message = "7035220576657273696f6e0000000000550000009c7c00000100000000000000e615104d00000000010000000000000000000000000000000000ffff0a000001208d010000000000000000000000000000000000ffff0a000002208ddd9d202c3ab457130055810100",
Test = new Action <object>(o =>
{
var version = (VersionPayload)o;
Assert.Equal((ulong)0x1357B43A2C209DDD, version.Nonce);
Assert.Equal("", version.UserAgent);
Assert.Equal("::ffff:10.0.0.2", version.AddressFrom.Address.ToString());
Assert.Equal(8333, version.AddressFrom.Port);
Assert.Equal(0x00018155, version.StartHeight);
Assert.Equal((ProtocolVersion)31900, version.Version);
})
},
new
{
Version = ProtocolVersion.MEMPOOL_GD_VERSION,
Message = "7035220576657273696f6e000000000064000000358d493262ea0000010000000000000011b2d05000000000010000000000000000000000000000000000ffff000000000000000000000000000000000000000000000000ffff0000000000003b2eb35d8ce617650f2f5361746f7368693a302e372e322fc03e0300",
Test = new Action <object>(o =>
{
var version = (VersionPayload)o;
Assert.Equal("/Satoshi:0.7.2/", version.UserAgent);
Assert.Equal(0x00033EC0, version.StartHeight);
})
},
new
{
Version = ProtocolVersion.PROTOCOL_VERSION,
Message = "7035220576657261636b000000000000000000005df6e0e2",
Test = new Action <object>(o =>
{
var verack = (VerAckPayload)o;
})
},
new
{
Version = ProtocolVersion.MEMPOOL_GD_VERSION,
Message = "703522056164647200000000000000001f000000ed52399b01e215104d010000000000000000000000000000000000ffff0a000001208d",
Test = new Action <object>(o =>
{
var addr = (AddrPayload)o;
Assert.Equal(1, addr.Addresses.Length);
//"Mon Dec 20 21:50:10 EST 2010"
var date = TimeZoneInfo.ConvertTime(addr.Addresses[0].Time, EST);
Assert.Equal(20, date.Day);
Assert.Equal(12, date.Month);
Assert.Equal(2010, date.Year);
Assert.Equal(21, date.Hour);
})
},
};
foreach (var test in tests)
{
var message = Network.StratisMain.ParseMessage(TestUtils.ParseHex(test.Message), test.Version);
test.Test(message.Payload);
var bytes = message.ToBytes(test.Version);
var old = message;
message = new Message();
message.FromBytes(bytes, test.Version);
test.Test(message.Payload);
Assert.Equal(test.Message, Encoders.Hex.EncodeData(message.ToBytes(test.Version)));
}
}
public void base58_keys_valid_gen()
{
var tests = TestCase.read_json("data/base58_keys_valid.json");
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.TestNet;
}
else
{
network = Network.Main;
}
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 == "none")
{
dest = new TxDestination(0);
}
else
{
Assert.True(false, "Bad addrtype: " + strTest);
continue;
}
try
{
BitcoinAddress addrOut = network.CreateBitcoinAddress(dest);
Assert.True(addrOut.ToString() == exp_base58string, "mismatch: " + strTest);
}
catch (ArgumentException)
{
Assert.True(dest.GetType() == typeof(TxDestination));
}
}
}
// Visiting a CNoDestination must fail
TxDestination nodest = new TxDestination();
Assert.Throws <ArgumentException>(() => network.CreateBitcoinAddress(nodest));
}
