public static void CanParseRev()
{
BlockUndoStore src = new BlockUndoStore(TestDataLocations.DataFolder(@"blocks"), Network.Main);
BlockUndoStore dest = CreateBlockUndoStore();
int count = 0;
foreach (var un in src.EnumerateFolder())
{
var expectedSize = un.Header.ItemSize;
var actualSize = (uint)un.Item.GetSerializedSize();
Assert.Equal(expectedSize, actualSize);
dest.Append(un.Item);
count++;
}
Assert.Equal(8, count);
count = 0;
foreach (var un in dest.EnumerateFolder())
{
var expectedSize = un.Header.ItemSize;
var actualSize = (uint)un.Item.GetSerializedSize();
Assert.Equal(expectedSize, actualSize);
count++;
}
Assert.Equal(8, count);
}
public void CanEnumerateBlockInAFileRange()
{
var store = new BlockStore(TestDataLocations.DataFolder(@"blocks"), Network.Main);
var result = store.Enumerate(new DiskBlockPosRange(new DiskBlockPos(1, 0), new DiskBlockPos(2, 0))).ToList();
Assert.Equal(2000, result.Count);
}
public void CanReIndex()
{
var source = new BlockStore(TestDataLocations.DataFolder(@"blocks"), Network.Main);
var store = CreateBlockStore("CanReIndexFolder");
store.AppendAll(source.Enumerate(false).Take(100).Select(b => b.Item));
var test = new IndexedBlockStore(new InMemoryNoSqlRepository(), store);
var reIndexed = test.ReIndex();
Assert.Equal(100, reIndexed);
int i = 0;
foreach (var b in store.Enumerate(true))
{
var result = test.Get(b.Item.GetHash());
Assert.Equal(result.GetHash(), b.Item.GetHash());
i++;
}
Assert.Equal(100, i);
var last = source.Enumerate(false).Skip(100).FirstOrDefault();
store.Append(last.Item);
reIndexed = test.ReIndex();
Assert.Equal(1, reIndexed);
reIndexed = test.ReIndex();
Assert.Equal(0, reIndexed);
}
public void CanBuildChainFromBlocks()
{
var store = new BlockStore(TestDataLocations.DataFolder(@"blocks"), Network.Main);
var chain = store.GetChain();
Assert.True(chain.Height == 3999);
}
public void CanDecodeAndEncodeRawTransaction()
{
if (RPCClientTests.noClient)
{
return;
}
var tests = TestCase.read_json(TestDataLocations.DataFolder(@"tx_raw.json"));
using (var builder = NodeBuilder.Create())
{
var rpc = builder.CreateNode().CreateRPCClient();
builder.StartAll();
var index = 0;
foreach (var test in tests)
{
var format = (RawFormat)Enum.Parse(typeof(RawFormat), (string)test[0], true);
var network = ((string)test[1]) == "Main" ? Network.Main : Network.TestNet;
var testData = ((JObject)test[2]).ToString();
Transaction raw = Transaction.Parse(testData, format, network);
AssertJsonEquals(raw.ToString(format, network), testData);
var raw3 = Transaction.Parse(raw.ToString(format, network), format);
Assert.Equal(raw.ToString(format, network), raw3.ToString(format, network));
index++;
}
}
}
public void CanReadPaymentRequest()
{
foreach (var provider in new ICertificateServiceProvider[]
{
#if WIN
new WindowsCertificateServiceProvider(X509VerificationFlags.IgnoreNotTimeValid |
X509VerificationFlags.AllowUnknownCertificateAuthority |
X509VerificationFlags.IgnoreRootRevocationUnknown |
X509VerificationFlags.IgnoreCertificateAuthorityRevocationUnknown |
X509VerificationFlags.IgnoreEndRevocationUnknown)
#endif
})
{
PaymentRequest.DefaultCertificateServiceProvider = provider;
var request = LoadPaymentRequest(TestDataLocations.DataFolder(@"payreq1_sha1.paymentrequest"));
AssertEx.CollectionEquals(request.ToBytes(), File.ReadAllBytes(TestDataLocations.DataFolder(@"payreq1_sha1.paymentrequest")));
Assert.True(request.VerifySignature());
request.Details.Memo = "lol";
Assert.False(request.VerifySignature());
request.Details.Memo = "this is a memo";
Assert.True(request.VerifySignature());
Assert.True(request.VerifyChain());
request = LoadPaymentRequest(TestDataLocations.DataFolder(@"payreq2_sha1.paymentrequest"));
AssertEx.CollectionEquals(request.ToBytes(), File.ReadAllBytes(TestDataLocations.DataFolder(@"payreq2_sha1.paymentrequest")));
Assert.True(request.VerifySignature());
}
}
public void DeterministicSignatureTestVectors()
{
foreach (var test in ParseTestsDump(File.ReadAllText(TestDataLocations.DataFolder("determiniticECDSA.txt"))))
{
TestSig(test);
}
}
public void CanCalculateMerkleRoot()
{
Block block = new Block();
block.ReadWrite(Encoders.Hex.DecodeData(File.ReadAllText(TestDataLocations.DataFolder("block1125.txt"))));
Assert.Equal(block.Header.HashMerkleRoot, block.GetMerkleRoot().Hash);
}
public void CanEnumerateBlockCountRange()
{
var store = new BlockStore(TestDataLocations.DataFolder(@"blocks"), Network.Main);
var expectedBlock = store.Enumerate(false).Skip(4).First();
var actualBlocks = store.Enumerate(false, 4, 2).ToArray();
Assert.Equal(2, actualBlocks.Length);
Assert.Equal(expectedBlock.Item.Header.GetHash(), actualBlocks[0].Item.Header.GetHash());
Assert.True(actualBlocks[0].Item.CheckMerkleRoot());
}
//[Fact]
//[Trait("UnitTest", "UnitTest")]
public void CanParsePaymentACK()
{
var ack = LoadPaymentACK(TestDataLocations.DataFolder(@"paymentack.data"));
Assert.Equal("thanks customer !", ack.Memo);
Assert.Equal("thanks merchant !", ack.Payment.Memo);
Assert.Equal(2, ack.Payment.Transactions.Count);
Assert.Equal(2, ack.Payment.RefundTo.Count);
AssertEx.CollectionEquals(ack.ToBytes(), PaymentACK.Load(ack.ToBytes()).ToBytes());
AssertEx.CollectionEquals(ack.ToBytes(), File.ReadAllBytes(TestDataLocations.DataFolder(@"paymentack.data")));
}
//[Fact]
//[Trait("UnitTest", "UnitTest")]
public void CanParseBlockJSON()
{
// disabled for now
var jobj = JObject.Parse(File.ReadAllText(TestDataLocations.DataFolder(@"blocks/Block1.json")));
var array = (JArray)jobj["mrkl_tree"];
var expected = array.OfType <JValue>().Select(v => uint256.Parse(v.ToString())).ToList();
var block = Block.ParseJson(File.ReadAllText(TestDataLocations.DataFolder(@"blocks/Block1.json")));
Assert.Equal("000000000000000040cd080615718eb68f00a0138706e7afd4068f3e08d4ca20", block.GetHash().ToString());
Assert.True(block.CheckMerkleRoot());
}
public void CanStoreInBlockRepository()
{
var blockRepository = CreateBlockRepository();
var firstblk1 = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).First();
blockRepository.WriteBlockHeader(firstblk1.Item.Header);
var result = blockRepository.GetBlock(firstblk1.Item.GetHash());
Assert.True(result.HeaderOnly);
blockRepository.WriteBlock(firstblk1.Item);
result = blockRepository.GetBlock(firstblk1.Item.GetHash());
Assert.False(result.HeaderOnly);
}
public void CanReadStoredBlockFolder()
{
var blk0 = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat"), (uint)1).ToList();
var blk1 = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0002.dat"), (uint)2).ToList();
int count = 0;
foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks")))
{
if (count == 0)
{
Assert.Equal(blk0[0].Item.GetHash(), stored.Item.GetHash());
}
if (count == 2000)
{
Assert.Equal(blk1[0].Item.GetHash(), stored.Item.GetHash());
}
Assert.True(stored.Item.Check());
count++;
}
Assert.Equal(4000, count);
count = 0;
foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk1[1998].BlockPosition)))
{
count++;
}
Assert.Equal(2, count);
count = 0;
foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[1998].BlockPosition)))
{
count++;
}
Assert.Equal(2002, count);
count = 0;
foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[1998].BlockPosition, blk1[2].BlockPosition)))
{
count++;
}
Assert.Equal(4, count);
count = 0;
foreach (var stored in StoredBlock.EnumerateFolder(TestDataLocations.DataFolder(@"blocks"), new DiskBlockPosRange(blk0[30].BlockPosition, blk0[34].BlockPosition)))
{
count++;
}
Assert.Equal(4, count);
}
public void CanIndexBlock()
{
var index = CreateIndexedStore();
foreach (var block in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(50))
{
index.Put(block.Item);
}
var genesis = index.Get(uint256.Parse("0x0000066e91e46e5a264d42c89e1204963b2ee6be230b443e9159020539d972af"));
Assert.NotNull(genesis);
var invalidBlock = index.Get(uint256.Parse("0x0000066e91e46e5a264d42c89e1204963b2ee6be230b443e9159020539d972ae"));
Assert.Null(invalidBlock);
}
public void CanVerifyValidChain()
{
foreach (var provider in new ICertificateServiceProvider[]
{
#if WIN
new WindowsCertificateServiceProvider(X509VerificationFlags.IgnoreNotTimeValid, X509RevocationMode.NoCheck)
#endif
})
{
PaymentRequest.DefaultCertificateServiceProvider = provider;
var req = LoadPaymentRequest(TestDataLocations.DataFolder(@"payreq3_validchain.paymentrequest"));
Assert.True(req.VerifyChain());
Assert.True(req.VerifySignature());
}
}
public void CanCreatePaymentMessageAndACK()
{
var request = LoadPaymentRequest(TestDataLocations.DataFolder(@"payreq1_sha1.paymentrequest"));
var payment = request.CreatePayment();
AssertEx.CollectionEquals(request.Details.MerchantData, payment.MerchantData);
AssertEx.CollectionEquals(payment.ToBytes(), PaymentMessage.Load(payment.ToBytes()).ToBytes());
payment.Memo = "thanks merchant !";
AssertEx.CollectionEquals(payment.ToBytes(), PaymentMessage.Load(payment.ToBytes()).ToBytes());
var ack = payment.CreateACK();
AssertEx.CollectionEquals(ack.Payment.ToBytes(), PaymentMessage.Load(payment.ToBytes()).ToBytes());
AssertEx.CollectionEquals(ack.ToBytes(), PaymentACK.Load(ack.ToBytes()).ToBytes());
ack.Memo = "thanks customer !";
AssertEx.CollectionEquals(ack.ToBytes(), PaymentACK.Load(ack.ToBytes()).ToBytes());
}
private AlertPayload[] ReadAlerts()
{
List <AlertPayload> alerts = new List <AlertPayload>();
using (var fs = File.OpenRead(TestDataLocations.DataFolder(@"alertTests.raw")))
{
BitcoinStream stream = new BitcoinStream(fs, false);
while (stream.Inner.Position != stream.Inner.Length)
{
AlertPayload payload = null;
stream.ReadWrite(ref payload);
alerts.Add(payload);
}
}
return(alerts.ToArray());
}
public void CanStoreBlocksInMultipleFiles()
{
var store = CreateBlockStore();
store.MaxFileSize = 10; //Verify break all block in one respective file with extreme settings
var allBlocks = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(10).ToList();
foreach (var s in allBlocks)
{
store.Append(s.Item);
}
var storedBlocks = store.Enumerate(true).ToList();
Assert.Equal(allBlocks.Count, storedBlocks.Count);
Assert.Equal(11, store.Folder.GetFiles().Length); //10 files + lock file
}
void ListenerCallback(IAsyncResult ar)
{
try
{
var context = _Listener.EndGetContext(ar);
var type = context.Request.QueryString.Get("type");
var businessId = int.Parse(context.Request.QueryString.Get("id"));
if (type == "Request")
{
Assert.Equal(PaymentRequest.MediaType, context.Request.AcceptTypes[0]);
context.Response.ContentType = PaymentRequest.MediaType;
PaymentRequest request = new PaymentRequest();
request.Details.MerchantData = BitConverter.GetBytes(businessId);
request.Details.PaymentUrl = new Uri(_Prefix + "?id=" + businessId + "&type=Payment");
request.Sign(File.ReadAllBytes(TestDataLocations.DataFolder(@"PaymentMerchant.pfx")), PKIType.X509SHA256);
request.WriteTo(context.Response.OutputStream);
}
else if (type == "Payment")
{
Assert.Equal(PaymentMessage.MediaType, context.Request.ContentType);
Assert.Equal(PaymentACK.MediaType, context.Request.AcceptTypes[0]);
var payment = PaymentMessage.Load(context.Request.InputStream);
Assert.Equal(businessId, BitConverter.ToInt32(payment.MerchantData, 0));
context.Response.ContentType = PaymentACK.MediaType;
var ack = payment.CreateACK();
ack.WriteTo(context.Response.OutputStream);
}
else
{
Assert.False(true, "Impossible");
}
context.Response.Close();
_Listener.BeginGetContext(ListenerCallback, null);
}
catch (Exception)
{
if (!_Stopped)
{
throw;
}
}
}
public void CanReadStoredBlockFile()
{
int count = 0;
foreach (var stored in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")))
{
Assert.True(stored.Item.Check());
count++;
}
Assert.Equal(2000, count);
count = 0;
var twoLast = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Skip(1998).ToList();
foreach (var stored in StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat"), range: new DiskBlockPosRange(twoLast[0].BlockPosition)))
{
count++;
}
Assert.Equal(2, count);
}
public void CanStoreBlocks()
{
var store = CreateBlockStore();
var allBlocks = StoredBlock.EnumerateFile(TestDataLocations.DataBlockFolder("blk0001.dat")).Take(50).ToList();
foreach (var s in allBlocks)
{
store.Append(s.Item);
}
var storedBlocks = store.Enumerate(true).ToList();
Assert.Equal(allBlocks.Count, storedBlocks.Count);
foreach (var s in allBlocks)
{
var retrieved = store.Enumerate(true).First(b => b.Item.GetHash() == s.Item.GetHash());
Assert.True(retrieved.Item.HeaderOnly);
}
}
public void CanCreatePaymentRequest()
{
foreach (var provider in new ICertificateServiceProvider[]
{
#if WIN
new WindowsCertificateServiceProvider(X509VerificationFlags.IgnoreNotTimeValid)
#endif
})
{
PaymentRequest.DefaultCertificateServiceProvider = provider;
var cert = File.ReadAllBytes(TestDataLocations.DataFolder(@"PaymentMerchant.pfx"));
CanCreatePaymentRequestCore(cert);
#if WIN
if (provider is WindowsCertificateServiceProvider)
{
CanCreatePaymentRequestCore(new X509Certificate2(cert, "", X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet));
}
#endif
}
}
public void CanCalculateDifficulty()
{
var histories = File.ReadAllLines(TestDataLocations.DataFolder(@"targethistory.csv"));
var store = new BlockStore(TestDataLocations.BlockFolderLocation, Network.Main);
// todo: load the chain with a header only file
ConcurrentChain chain = store.GetChain();
foreach (var history in histories)
{
var height = int.Parse(history.Split(',')[0]);
var expectedTarget = new Target(BigInteger.Parse(history.Split(',')[1]));
var block = chain.GetBlock(height).Header;
Assert.Equal(expectedTarget, block.Bits);
var target = chain.GetWorkRequired(Network.Main, height);
Assert.Equal(expectedTarget, target);
}
}
//Compare between new old implementation of signature in reference bitcoin. But NBitcoin is like the old one, so we don't care about this test
//[Fact]
//public void sighash_test()
//{
// int nRandomTests = 50000;
// for(int i = 0 ; i < nRandomTests ; i++)
// {
// int nHashType = rand.Next();
// Transaction txTo = RandomTransaction((nHashType & 0x1f) == SigHash.Single);
// Script scriptCode = RandomScript();
// int nIn = rand.Next() % txTo.VIn.Length;
// var sho = SignatureHashOld(scriptCode, txTo, nIn, nHashType);
// var sh = scriptCode.SignatureHash(txTo, nIn, (SigHash)nHashType);
// Assert.True(sh == sho);
// }
//}
// Goal: check that SignatureHash generates correct hash
//[Fact]
//[Trait("Core", "Core")]
public void sighash_from_data()
{
// test diabled for now as it requires specific test data
var tests = TestCase.read_json(TestDataLocations.DataFolder(@"sighash.json"));
foreach (var test in tests)
{
var strTest = test.ToString();
if (test.Count < 1) // Allow for extra stuff (useful for comments)
{
Assert.True(false, "Bad test: " + strTest);
continue;
}
if (test.Count == 1)
{
continue; // comment
}
string raw_tx, raw_script, sigHashHex;
int nIn, nHashType;
Transaction tx = new Transaction();
Script scriptCode = new Script();
// deserialize test data
raw_tx = (string)test[0];
raw_script = (string)test[1];
nIn = (int)(long)test[2];
nHashType = (int)(long)test[3];
sigHashHex = (string)test[4];
tx.ReadWrite(ParseHex(raw_tx));
var raw = ParseHex(raw_script);
scriptCode = new Script(raw);
var sh = Script.SignatureHash(scriptCode, tx, nIn, (SigHash)nHashType);
Assert.True(sh.ToString() == sigHashHex, strTest);
}
}
public void JapTest()
{
var test = JArray.Parse(File.ReadAllText(TestDataLocations.DataFolder(@"bip39_JP.json"), Encoding.UTF32));
foreach (var unitTest in test.OfType <JObject>())
{
var entropy = Encoders.Hex.DecodeData(unitTest["entropy"].ToString());
string mnemonicStr = unitTest["mnemonic"].ToString();
string seed = unitTest["seed"].ToString();
string passphrase = unitTest["passphrase"].ToString();
var mnemonic = new Mnemonic(mnemonicStr, Wordlist.Japanese);
Assert.True(mnemonic.IsValidChecksum);
Assert.Equal(seed, Encoders.Hex.EncodeData(mnemonic.DeriveSeed(passphrase)));
var bip32 = unitTest["bip32_xprv"].ToString();
var bip32Actual = mnemonic.DeriveExtKey(passphrase).ToString(Network.Main);
Assert.Equal(bip32, bip32Actual.ToString());
mnemonic = new Mnemonic(Wordlist.Japanese, entropy);
Assert.True(mnemonic.IsValidChecksum);
bip32Actual = mnemonic.DeriveExtKey(passphrase).ToString(Network.Main);
Assert.Equal(bip32, bip32Actual.ToString());
}
}
public void CanReadTestVectorPayments()
{
var tests = new[]
{
TestDataLocations.DataFolder(@"payreq1_sha256_omitteddefault.paymentrequest"),
TestDataLocations.DataFolder(@"payreq1_sha256.paymentrequest"),
TestDataLocations.DataFolder(@"payreq2_sha256_omitteddefault.paymentrequest"),
TestDataLocations.DataFolder(@"payreq2_sha256.paymentrequest"),
TestDataLocations.DataFolder(@"payreq1_sha1_omitteddefault.paymentrequest"),
TestDataLocations.DataFolder(@"payreq1_sha1.paymentrequest"),
TestDataLocations.DataFolder(@"payreq2_sha1_omitteddefault.paymentrequest"),
TestDataLocations.DataFolder(@"payreq2_sha1.paymentrequest"),
};
foreach (var provider in new ICertificateServiceProvider[]
{
#if WIN
new WindowsCertificateServiceProvider(X509VerificationFlags.IgnoreNotTimeValid |
X509VerificationFlags.AllowUnknownCertificateAuthority |
X509VerificationFlags.IgnoreRootRevocationUnknown |
X509VerificationFlags.IgnoreCertificateAuthorityRevocationUnknown |
X509VerificationFlags.IgnoreEndRevocationUnknown)
#endif
})
{
PaymentRequest.DefaultCertificateServiceProvider = provider;
foreach (var test in tests)
{
var bytes = File.ReadAllBytes(test);
var request = PaymentRequest.Load(bytes);
AssertEx.Equal(request.ToBytes(), bytes);
Assert.True(request.VerifySignature());
request = PaymentRequest.Load(PaymentRequest.Load(bytes).ToBytes());
Assert.True(request.VerifySignature());
Assert.True(request.VerifyChain());
}
}
}
public void EngTest()
{
var test = JObject.Parse(File.ReadAllText(TestDataLocations.DataFolder(@"bip39_vectors.json")));
foreach (var language in test.Properties())
{
var lang = GetList(language.Name);
foreach (var langTest in ((JArray)language.Value).OfType <JArray>().Take(2))
{
var entropy = Encoders.Hex.DecodeData(langTest[0].ToString());
string mnemonicStr = langTest[1].ToString();
string seed = langTest[2].ToString();
var mnemonic = new Mnemonic(mnemonicStr, lang);
Assert.True(mnemonic.IsValidChecksum);
Assert.Equal(seed, Encoders.Hex.EncodeData(mnemonic.DeriveSeed("TREZOR")));
mnemonic = new Mnemonic(lang, entropy);
Assert.True(mnemonic.IsValidChecksum);
Assert.Equal(seed, Encoders.Hex.EncodeData(mnemonic.DeriveSeed("TREZOR")));
}
}
}
public void CanSerializeDeserializePeerTable()
{
AddressManager addrman = new AddressManager();
addrman.SavePeerFile("CanSerializeDeserializePeerTable.dat", Network.Main);
AddressManager.LoadPeerFile("CanSerializeDeserializePeerTable.dat", Network.Main);
addrman = AddressManager.LoadPeerFile(TestDataLocations.DataFolder("peers.dat"), Network.Main);
addrman.DebugMode = true;
addrman.Check();
addrman.SavePeerFile("serializerPeer.dat", Network.Main);
AddressManager addrman2 = AddressManager.LoadPeerFile("serializerPeer.dat", Network.Main);
addrman2.DebugMode = true;
addrman2.Check();
addrman2.SavePeerFile("serializerPeer2.dat", Network.Main);
var original = File.ReadAllBytes("serializerPeer2.dat");
var after = File.ReadAllBytes("serializerPeer.dat");
Assert.True(original.SequenceEqual(after));
}
public void base58_keys_valid_parse()
{
var tests = TestCase.read_json(TestDataLocations.DataFolder("base58_keys_valid.json"));
Network network;
foreach (var 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)
{
continue;
}
//network = Network.TestNet;
else
{
network = BitcoinNetwork.Main;
}
if (isPrivkey)
{
bool isCompressed = (bool)test.GetDynamic(2).isCompressed;
// Must be valid private key
// Note: CBitcoinSecret::SetString tests isValid, whereas CBitcoinAddress does not!
var 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
var 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 ColoredCoinTester([CallerMemberName] string test = null)
{
var testcase = JsonConvert.DeserializeObject <TestCase[]>(File.ReadAllText(TestDataLocations.DataFolder(@"openasset-known-tx.json")))
.First(t => t.test == test);
NoSqlTransactionRepository repository = new NoSqlTransactionRepository();
foreach (var tx in testcase.txs)
{
var txObj = Transaction.Parse(tx);
repository.Put(txObj.GetHash(), txObj);
}
TestedTxId = uint256.Parse(testcase.testedtx);
Repository = new NullColoredTransactionRepository(repository);
}