NBitcoin.uint256.Parse(string)

Here are the examples of the csharp api NBitcoin.uint256.Parse(string) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

88 Examples 7

19 Source : BitcoinMS.cs
with MIT License
from PacktPublishing

private void SpendMoney()
        {
            using (var scope = _container?.BeginLifetimeScope())
            {
                var logger = scope?.Resolve<MSBaseLogger>();
                logger?.LogInformation(Name + " Bitcoin SpendMoney");
                Console.WriteLine("Spending Money", Color.Aqua);

                #region IMPORT PRIVKEY

                var bitcoinPrivateKey = new BitcoinSecret("cSZjE4aJNPpBtU6xvJ6J4iBzDgTmzTjbq8w2kqnYvAprBCyTsG4x");
                var network = bitcoinPrivateKey.Network;

                #endregion

                var address = bitcoinPrivateKey.GetAddress();
                logger?.LogInformation(bitcoinPrivateKey.ToString());
                logger?.LogInformation(address?.ToString());


                var client = new QBitNinjaClient(network);
                var transactionId = uint256.Parse("e44587cf08b4f03b0e8b4ae7562217796ec47b8c91666681d71329b764add2e3");
                var transactionResponse = client.GetTransaction(transactionId)?.Result;

                logger?.LogInformation(transactionResponse?.TransactionId.ToString());
                logger?.LogInformation(transactionResponse?.Block.Confirmations.ToString());


                var receivedCoins = transactionResponse?.ReceivedCoins;
                OutPoint outPointToSpend = null;
                foreach (var coin in receivedCoins)
                {
                    if (coin.TxOut?.ScriptPubKey == bitcoinPrivateKey.ScriptPubKey)
                    {
                        outPointToSpend = coin.Outpoint;
                    }
                }

                if (outPointToSpend == null)
                    throw new Exception("TxOut doesn't contain our ScriptPubKey");
                logger?.LogInformation("We want to spend " + outPointToSpend.N + 1 + ". outpoint:");
                Console.WriteLine("We want to spend " + outPointToSpend.N + 1 + ". outpoint:", Color.Aqua);

                var transaction = new Transaction();
                transaction.Inputs?.Add(new TxIn()
                {
                    PrevOut = outPointToSpend
                });

                var hallOfTheMakersAddress = new BitcoinPubKeyAddress("mzp4No5cmCXjZUpf112B1XWsvWBfws5bbB");

                // How much you want to TO
                var hallOfTheMakersAmount = new Money((decimal) 0.5, MoneyUnit.BTC);
                var minerFee = new Money((decimal) 0.0001, MoneyUnit.BTC);
                // How much you want to spend FROM
                var txInAmount = (Money) receivedCoins[(int) outPointToSpend.N]?.Amount;
                Money changeBackAmount = txInAmount - hallOfTheMakersAmount - minerFee;

                TxOut hallOfTheMakersTxOut = new TxOut()
                {
                    Value = hallOfTheMakersAmount,
                    ScriptPubKey = hallOfTheMakersAddress.ScriptPubKey
                };

                TxOut changeBackTxOut = new TxOut()
                {
                    Value = changeBackAmount,
                    ScriptPubKey = bitcoinPrivateKey.ScriptPubKey
                };

                transaction.Outputs?.Add(hallOfTheMakersTxOut);
                transaction.Outputs?.Add(changeBackTxOut);

                var message = "Our first bitcoin transaction together!";
                var bytes = Encoding.UTF8.GetBytes(message);
                transaction.Outputs?.Add(new TxOut()
                {
                    Value = Money.Zero,
                    ScriptPubKey = TxNullDataTemplate.Instance?.GenerateScriptPubKey(bytes)
                });

                // It is also OK:
                transaction.Inputs[0].ScriptSig = bitcoinPrivateKey.ScriptPubKey;
                transaction.Sign(bitcoinPrivateKey, false);

                BroadcastResponse broadcastResponse = client.Broadcast(transaction)?.Result;

                BitcoinSpendReceipt r = new BitcoinSpendReceipt();
                if (!broadcastResponse.Success)
                {
                    logger?.LogError($"ErrorCode: {broadcastResponse.Error.ErrorCode}");
                    Console.WriteLine($"ErrorCode: {broadcastResponse.Error.ErrorCode}", Color.Red);
                    logger?.LogError("Error message: " + broadcastResponse.Error.Reason);
                    Console.WriteLine("Error message: " + broadcastResponse.Error.Reason, Color.Red);
                    r.success = false;
                }
                else
                {
                    logger?.LogInformation("Success! You can check out the hash of the transaction in any block explorer:");
                    Console.WriteLine("Success! You can check out the hash of the transaction in any block explorer:", Color.Green);
                    logger?.LogInformation(transaction.GetHash()?.ToString());
                    Console.WriteLine(transaction.GetHash()?.ToString(), Color.Green);
                    r.success = true;
                }

                r.time = SystemClock.Instance.GetCurrentInstant().ToDateTimeUtc();
                r.amount = txInAmount.ToDecimal(MoneyUnit.BTC);
                Bus.Publish(r, "Bitcoin");
            }
        }

19 Source : IndexBlocksTask.cs
with MIT License
from stratisproject

protected override void IndexCore(string parreplacedionName, IEnumerable<BlockInfo> blocks)
        {
            var from = blocks.FirstOrDefault()?.Height;
            var to = blocks.LastOrDefault()?.Height;

            this.logger.LogDebug("Indexing blocks from {0} to {1}", from, to);

            BlockInfo first = blocks.First();
            Block block = first.Block;
            var hash = first.BlockId.ToString();

            // Stopwatch watch = new Stopwatch();
            // watch.Start();
            while (true)
            {
                CloudBlobContainer container = this.Configuration.GetBlocksContainer();
                CloudBlobClient client = container.ServiceClient;
                client.DefaultRequestOptions.SingleBlobUploadThresholdInBytes = 32 * 1024 * 1024;
                CloudPageBlob blob = container.GetPageBlobReference(hash);
                MemoryStream ms = new MemoryStream();
                block.ReadWrite(ms, true);
                byte[] blockBytes = ms.GetBuffer();

                long length = 512 - (ms.Length % 512);
                if (length == 512)
                {
                    length = 0;
                }

                Array.Resize(ref blockBytes, (int)(ms.Length + length));

                try
                {
                    blob.UploadFromByteArrayAsync(blockBytes, 0, blockBytes.Length, new AccessCondition()
                    {
                        // TODO Review that param.
                        IfNotModifiedSinceTime = DateTimeOffset.MinValue
                    },
                    new BlobRequestOptions() { MaximumExecutionTime = this.Timeout, ServerTimeout = this.Timeout },
                    new OperationContext())
                        .GetAwaiter()
                        .GetResult();

                    // watch.Stop();
                    // IndexerTrace.BlockUploaded(watch.Elapsed, blockBytes.Length);

                    this.indexedBlocks++;

                    this.logger.LogDebug("Completed Indexing blocks from {0} to {1}", from, to);

                    break;
                }
                catch (StorageException ex)
                {
                    var alreadyExist = ex.RequestInformation != null && ex.RequestInformation.HttpStatusCode == 412;
                    if (!alreadyExist)
                    {
                        IndexerTrace.ErrorWhileImportingBlockToAzure(uint256.Parse(hash), ex);
                    }

                    // watch.Stop();
                    // IndexerTrace.BlockAlreadyUploaded();
                    this.indexedBlocks++;

                    this.logger.LogDebug(ex, "Storage exception occurred: {0}", ex.ToString());
                    break;
                }
                catch (Exception ex)
                {
                    IndexerTrace.ErrorWhileImportingBlockToAzure(uint256.Parse(hash), ex);

                    this.logger.LogError(ex, "Exception occurred: {0}", ex.ToString());
                    throw;
                }
            }
        }

19 Source : SmartContractsController.cs
with MIT License
from stratisproject

[HttpGet]
        [Route("")]
        public async Task<List<TransactionSummaryModel>> SmartContracts(bool loadDetails = false, int take = 10)
        {
            var txs = new List<TransactionSummaryModel>();
            if (!this.configuration.Indexer.IsSidechain) return txs;
            var lastSmartContracts = await this.smartContractSearchService.GetAllSmartContracts(null, loadDetails);
            if (lastSmartContracts == null)
            {
                return txs;
            }

            foreach (var smartContractModel in lastSmartContracts.Take(take))
            {
                var response = await this.transactionSearchService.FindTransaction(uint256.Parse(smartContractModel.TxId), false);
                var mappedResponse = this.mapper.Map<TransactionSummaryModel>(response);
                mappedResponse.SmartContract = smartContractModel;
                txs.Add(mappedResponse);
            }

            return txs;
        }

19 Source : TransactionsController.cs
with MIT License
from stratisproject

[HttpGet]
        [Route("{txId}")]
        public async Task<TransactionSummaryModel> Transaction(string txId, bool colored = false, bool loadSmartContractIfExists = false)
        {
            var response = await this.transactionSearchService.FindTransaction(uint256.Parse(txId), colored);
            var mappedResponse = this.mapper.Map<TransactionSummaryModel>(response);

            if (loadSmartContractIfExists) // TODO: put this in once we have real data && mappedResponse.IsSmartContract)
            {
                mappedResponse.SmartContract =
                    await this.smartContractSearchService.FindSmartContract(uint256.Parse(response.TransactionId));
            }

            return mappedResponse;
        }

19 Source : WhatIsIt.cs
with MIT License
from stratisproject

public async Task<object> Find(string data, IMapper mapper)
        {
            data = data.Trim();
            var b58 = this.NoException(() => WhatIsBase58.GetFromBitcoinString(data));
            if (b58 != null)
            {
                if (b58 is WhatIsAddress address)
                {
                    this.TryFetchRedeemOrPubKey(address);
                }

                return mapper.Map<WhatIsAddressModel>(b58);
            }

            if (data.Length == 0x40)
            {
                try
                {
                    return await this.Controller.JsonTransaction(uint256.Parse(data), false);
                }
                catch
                {
                }
            }

            var b = this.NoException(() => this.Controller.JsonBlock(BlockFeature.Parse(data), true, false));
            if (b != null)
            {
                return b;
            }

            // Hash of pubkey or script
            if (data.Length == 0x28)
            {
                TxDestination dest = new KeyId(data);
                var address = new WhatIsAddress(dest.GetAddress(this.Network));
                if (this.TryFetchRedeemOrPubKey(address))
                {
                    return mapper.Map<WhatIsAddressModel>(address);
                }

                dest = new ScriptId(data);
                address = new WhatIsAddress(dest.GetAddress(this.Network));
                if (this.TryFetchRedeemOrPubKey(address))
                {
                    return mapper.Map<WhatIsAddressModel>(address);
                }
            }

            var script = this.NoException(() => GetScriptFromBytes(data));
            if (script != null)
            {
                var scriptModel = new WhatIsScript(script, this.Network);
                return mapper.Map<WhatIsScriptModel>(scriptModel);
            }

            script = this.NoException(() => GetScriptFromText(data));
            if (script != null)
            {
                var scriptModel = new WhatIsScript(script, this.Network);
                return mapper.Map<WhatIsScriptModel>(scriptModel);
            }

            var sig = this.NoException(() => new TransactionSignature(Encoders.Hex.DecodeData(data)));
            if (sig != null)
            {
                return new WhatIsTransactionSignature(sig);
            }

            var pubkeyBytes = this.NoException(() => Encoders.Hex.DecodeData(data));
            if (pubkeyBytes != null && PubKey.Check(pubkeyBytes, true))
            {
                var pubKey = this.NoException(() => new PubKey(data));
                if (pubKey != null)
                {
                    var pubKeyModel = new WhatIsPublicKey(pubKey, this.Network);
                    return mapper.Map<WhatIsPublicKeyModel>(pubKeyModel);
                }
            }

            if (data.Length == 80 * 2)
            {
                var blockHeader = this.NoException(() =>
                {
                    var h = new BlockHeader();
                    h.ReadWrite(Encoders.Hex.DecodeData(data));
                    return h;
                });
                if (blockHeader != null)
                {
                    return new BlockHeaderResponse(blockHeader);
                }
            }

            return null;
        }

19 Source : UIntModelBinding.cs
with MIT License
from stratisproject

public Task BindModelAsync(ModelBindingContext bindingContext)
        {
            if (!typeof(uint256).IsreplacedignableFrom(bindingContext.ModelType))
            {
                return Task.CompletedTask;
            }

            ValueProviderResult val = bindingContext.ValueProvider.GetValue(
                bindingContext.ModelName);

            string key = val.FirstValue;
            if(key == null)
            {
                bindingContext.Model = null;
                return Task.CompletedTask;
            }
            
            bindingContext.Model = uint256.Parse(key);
            if (bindingContext.Model.ToString().StartsWith(uint160.Zero.ToString()))
                throw new FormatException("Invalid hash format");

            return Task.CompletedTask;
        }

19 Source : BlockFeature.cs
with MIT License
from stratisproject

public static BlockFeature Parse(string str)
        {
            var input = str;
            var feature = new BlockFeature();
            uint height;

            var split = str.Split(new[] { '-', '+' }, StringSplitOptions.None);
            if (split.Length != 1 && split.Length != 2)
                ThrowInvalidFormat();
            str = split[0];
            if(split.Length == 2)
            {
                var offset = TryParse(split[1]);
                feature.Offset = input.Contains("-") ? -offset : offset;
            }


            if (str.Equals("last", StringComparison.OrdinalIgnoreCase) || str.Equals("tip", StringComparison.OrdinalIgnoreCase))
            {
                feature.Special = SpecialFeature.Last;
                return feature;
            }

            if (uint.TryParse(str, out height))
            {
                feature.Height = (int)height;
                return feature;
            }

            if (str.Length == 0x40 && str.ToCharArray().All(c => HexEncoder.IsDigit(c) != -1))
            {
                feature.BlockId = uint256.Parse(str);
                return feature;
            }

            ThrowInvalidFormat();
            return null;
        }

19 Source : UIntModelBinding.cs
with MIT License
from stratisproject

public bool BindModel(System.Web.Http.Controllers.HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            if(!typeof(uint256).IsreplacedignableFrom(bindingContext.ModelType))
            {
                return false;
            }

            ValueProviderResult val = bindingContext.ValueProvider.GetValue(
                bindingContext.ModelName);
            if(val == null)
            {
                return false;
            }

            string key = val.RawValue as string;
            if(key == null)
            {
                bindingContext.Model = null;
                return true;
            }
            bindingContext.Model = uint256.Parse(key);
            if(bindingContext.Model.ToString().StartsWith(uint160.Zero.ToString()))
                throw new FormatException("Invalid hash format");
            return true;
        }

19 Source : WhatIsIt.cs
with MIT License
from stratisproject

public async Task<object> Find(string data)
        {
            data = data.Trim();
            var b58 = NoException(() => WhatIsBase58.GetFromBitcoinString(data));
            if (b58 != null)
            {
                if (b58 is WhatIsAddress)
                {
                    var address = (WhatIsAddress)b58;
                    TryFetchRedeemOrPubKey(address);
                }
                return b58;
            }

            if (data.Length == 0x40)
            {
                try
                {
                    return await Controller.JsonTransaction(uint256.Parse(data), false);
                }
                catch
                {
                }
            }
            var b = NoException(() => Controller.JsonBlock(BlockFeature.Parse(data), true, false));
            if (b != null)
                return b;

            if (data.Length == 0x28) //Hash of pubkey or script
            {
                TxDestination dest = new KeyId(data);
                var address = new WhatIsAddress(dest.GetAddress(Network));
                if (TryFetchRedeemOrPubKey(address))
                    return address;

                dest = new ScriptId(data);
                address = new WhatIsAddress(dest.GetAddress(Network));
                if (TryFetchRedeemOrPubKey(address))
                    return address;
            }


            var script = NoException(() => GetScriptFromBytes(data));
            if (script != null)
                return new WhatIsScript(script, Network);
            script = NoException(() => GetScriptFromText(data));
            if (script != null)
                return new WhatIsScript(script, Network);

            var sig = NoException(() => new TransactionSignature(Encoders.Hex.DecodeData(data)));
            if (sig != null)
                return new WhatIsTransactionSignature(sig);

            var pubkeyBytes = NoException(() => Encoders.Hex.DecodeData(data));
            if (pubkeyBytes != null && PubKey.Check(pubkeyBytes, true))
            {
                var pubKey = NoException(() => new PubKey(data));
                if (pubKey != null)
                    return new WhatIsPublicKey(pubKey, Network);
            }

            if (data.Length == 80 * 2)
            {
                var blockHeader = NoException(() =>
                {
                    var h = new BlockHeader();
                    h.ReadWrite(Encoders.Hex.DecodeData(data));
                    return h;
                });
                if (blockHeader != null)
                    return new WhatIsBlockHeader(blockHeader);
            }
            return null;
        }

19 Source : Class1.cs
with MIT License
from stratisproject

[Fact]
        public void CanGetTransaction()
        {
            var client = new QBitNinjaClient(Network.TestNet);
            var tx = client.GetTransaction(uint256.Parse("8412ef73d7c82cd9ac94004d20f79f1c1e6ecd93e340a4bacb735a24ec54c6b0")).Result;
            replacedert.NotNull(tx);
            replacedert.False(tx.ReceivedCoins.OfType<ColoredCoin>().Any());
            client.Colored = true;
            tx = client.GetTransaction(uint256.Parse("8412ef73d7c82cd9ac94004d20f79f1c1e6ecd93e340a4bacb735a24ec54c6b0")).Result;
            replacedert.True(tx.ReceivedCoins.OfType<ColoredCoin>().Any());
        }

19 Source : FederationWalletController.cs
with MIT License
from stratisproject

[HttpPost]
        [Route(FederationWalletRouteEndPoint.Sync)]
        public IActionResult Sync([FromBody] HashModel model)
        {
            if (!this.ModelState.IsValid)
            {
                return BuildErrorResponse(this.ModelState);
            }

            ChainedHeader block = this.chain.GetBlock(uint256.Parse(model.Hash));

            if (block == null)
            {
                return ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, $"Block with hash {model.Hash} was not found on the blockchain.", string.Empty);
            }

            this.walletSyncManager.SyncFromHeight(block.Height);
            return this.Ok();
        }

19 Source : WithdrawalExtractor.cs
with MIT License
from stratisproject

public IWithdrawal ExtractWithdrawalFromTransaction(Transaction transaction, uint256 blockHash, int blockHeight)
        {
            if (transaction.Outputs.Count(this.IsTargetAddressCandidate) != 1) return null;
            if (!this.IsOnlyFromMultisig(transaction)) return null;

            if (!this.opReturnDataReader.TryGetTransactionId(transaction, out string depositId))
                return null;

            this.logger.LogDebug(
                "Processing received transaction with source deposit id: {0}. Transaction hash: {1}.",
                depositId,
                transaction.GetHash());

            TxOut targetAddressOutput = transaction.Outputs.Single(this.IsTargetAddressCandidate);
            var withdrawal = new Withdrawal(
                uint256.Parse(depositId),
                transaction.GetHash(),
                targetAddressOutput.Value,
                targetAddressOutput.ScriptPubKey.GetDestinationAddress(this.network).ToString(),
                blockHeight,
                blockHash);

            return withdrawal;
        }

19 Source : BalancesController.cs
with MIT License
from stratisproject

[HttpGet]
        [Route("{balanceId}")]
        public async Task<BalanceResponseModel> AddressBalance(
            string balanceId,
            string continuation = null,
            string until = null,
            string from = null,
            bool includeImmature = false,
            bool unspentOnly = false,
            bool colored = false,
            bool loadTransactionDetails = false)
        {
            colored = colored || this.IsColoredAddress();
            BalanceModel balance = this.balanceSearchService.GetBalanceDetails(balanceId.ToBalanceId(this.Network), continuation.ToBalanceLocator(), until.ToBlockFeature(), from.ToBlockFeature(), includeImmature, unspentOnly, colored);
            var mappedBalance = this.mapper.Map<BalanceResponseModel>(balance);

            if (!loadTransactionDetails)
            {
                return mappedBalance;
            }

            foreach (var operation in mappedBalance.Operations)
            {
                var transaction = await this.transactionSearchService.FindTransaction(uint256.Parse(operation.TransactionId), false);
                operation.TransactionSummary = this.mapper.Map<TransactionSummaryModel>(transaction);
                operation.TransactionSummary.Spent = operation.Amount?.Satoshi < 0;
            }

            return mappedBalance;
        }

19 Source : BlocksController.cs
with MIT License
from stratisproject

[HttpGet]
        [Route("{block}")]
        public async Task<BlockResponseModel> Block(string block, bool headerOnly = false, bool extended = false)
        {
            var blockData = this.blockSearchService.GetBlock(block.ToBlockFeature(), headerOnly, extended);

            var mappedBlock = this.mapper.Map<BlockResponseModel>(blockData);
            if (mappedBlock.Block != null)
            {
                mappedBlock.Block.Transactions = new List<TransactionSummaryModel>();
                foreach (var transactionId in mappedBlock.Block.TransactionIds)
                {
                    var transaction =
                        await this.transactionSearchService.FindTransaction(uint256.Parse(transactionId), false);
                    var transactionSummary = this.mapper.Map<TransactionSummaryModel>(transaction);
                    transactionSummary.Spent = false;
                    mappedBlock.Block.Transactions.Add(transactionSummary);
                }
            }

            return mappedBlock;
        }

19 Source : MainController.cs
with MIT License
from stratisproject

[HttpGet]
        [Route("transactions/{txId}")]
        [Route("tx/{txId}")]
        public async Task<TransactionResponseModel> Transaction(string txId, bool colored = false)
        {
            var response = await this.JsonTransaction(uint256.Parse(txId), colored);
            return response;
        }

19 Source : BlockExplorerFormatter.cs
with MIT License
from stratisproject

protected override void BuildTransaction(JObject json, Transaction tx)
        {
            tx.Version = (uint)json.GetValue("ver");
            tx.LockTime = (uint)json.GetValue("lock_time");

            var vin = (JArray)json.GetValue("in");
            int vinCount = (int)json.GetValue("vin_sz");
            for(int i = 0; i < vinCount; i++)
            {
                var jsonIn = (JObject)vin[i];
                var txin = new TxIn();
                tx.Inputs.Add(txin);
                var prevout = (JObject)jsonIn.GetValue("prev_out");

                txin.PrevOut.Hash = uint256.Parse((string)prevout.GetValue("hash"));
                txin.PrevOut.N = (uint)prevout.GetValue("n");


                string script = (string)jsonIn.GetValue("scriptSig");
                if(script != null)
                {
                    txin.ScriptSig = new Script(script);
                }
                else
                {
                    string coinbase = (string)jsonIn.GetValue("coinbase");
                    txin.ScriptSig = new Script(Encoders.Hex.DecodeData(coinbase));
                }

                JToken seq = jsonIn.GetValue("sequence");
                if(seq != null)
                {
                    txin.Sequence = (uint)seq;
                }
            }

            var vout = (JArray)json.GetValue("out");
            int voutCount = (int)json.GetValue("vout_sz");
            for(int i = 0; i < voutCount; i++)
            {
                var jsonOut = (JObject)vout[i];
                var txout = new TxOut();
                tx.Outputs.Add(txout);

                txout.Value = Money.Parse((string)jsonOut.GetValue("value"));
                txout.ScriptPubKey = new Script((string)jsonOut.GetValue("scriptPubKey"));
            }
        }

19 Source : SatoshiFormatter.cs
with MIT License
from stratisproject

protected override void BuildTransaction(JObject json, Transaction tx)
        {
            tx.Version = (uint)json.GetValue("version");
            tx.LockTime = (uint)json.GetValue("locktime");

            var vin = (JArray)json.GetValue("vin");
            for(int i = 0; i < vin.Count; i++)
            {
                var jsonIn = (JObject)vin[i];
                var txin = new TxIn();
                tx.Inputs.Add(txin);

                var script = (JObject)jsonIn.GetValue("scriptSig");
                if(script != null)
                {
                    txin.ScriptSig = new Script(Encoders.Hex.DecodeData((string)script.GetValue("hex")));
                    txin.PrevOut.Hash = uint256.Parse((string)jsonIn.GetValue("txid"));
                    txin.PrevOut.N = (uint)jsonIn.GetValue("vout");
                }
                else
                {
                    string coinbase = (string)jsonIn.GetValue("coinbase");
                    txin.ScriptSig = new Script(Encoders.Hex.DecodeData(coinbase));
                }

                txin.Sequence = (uint)jsonIn.GetValue("sequence");

            }

            var vout = (JArray)json.GetValue("vout");
            for(int i = 0; i < vout.Count; i++)
            {
                var jsonOut = (JObject)vout[i];
                var txout = new TxOut();
                tx.Outputs.Add(txout);

                decimal btc = (decimal)jsonOut.GetValue("value");
                decimal satoshis = btc * Money.COIN;
                txout.Value = new Money((long)(satoshis));

                var script = (JObject)jsonOut.GetValue("scriptPubKey");
                txout.ScriptPubKey = new Script(Encoders.Hex.DecodeData((string)script.GetValue("hex")));
            }
        }

19 Source : IColoredTransactionRepository.cs
with MIT License
from stratisproject

public static Task<ColoredTransaction> GetAsync(this IColoredTransactionRepository repo, string txId)
        {
            return repo.GetAsync(uint256.Parse(txId));
        }

19 Source : IColoredTransactionRepository.cs
with MIT License
from stratisproject

public static ColoredTransaction Get(this IColoredTransactionRepository repo, string txId)
        {
            return repo.Get(uint256.Parse(txId));
        }

19 Source : Block.cs
with MIT License
from stratisproject

public static Block ParseJson(Network network, string json)
        {
            var formatter = new BlockExplorerFormatter(network);
            JObject block = JObject.Parse(json);
            var txs = (JArray)block["tx"];

            Block blk = network.Consensus.ConsensusFactory.CreateBlock();
            blk.Header.Bits = new Target((uint)block["bits"]);
            blk.Header.BlockTime = Utils.UnixTimeToDateTime((uint)block["time"]);
            blk.Header.Nonce = (uint)block["nonce"];
            blk.Header.Version = (int)block["ver"];
            blk.Header.HashPrevBlock = uint256.Parse((string)block["prev_block"]);
            blk.Header.HashMerkleRoot = uint256.Parse((string)block["mrkl_root"]);

            foreach (JToken tx in txs)
            {
                blk.AddTransaction(formatter.Parse((JObject)tx));
            }

            return blk;
        }

19 Source : ITransactionRepository.cs
with MIT License
from stratisproject

public static Task<Transaction> GetAsync(this ITransactionRepository repo, string txId)
        {
            return repo.GetAsync(uint256.Parse(txId));
        }

19 Source : ITransactionRepository.cs
with MIT License
from stratisproject

public static Transaction Get(this ITransactionRepository repo, string txId)
        {
            return repo.Get(uint256.Parse(txId));
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Bloom_match()
        {
            // Random real transaction (b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b)
            Transaction tx = this.network.CreateTransaction("01000000010b26e9b7735eb6aabdf358bab62f9816a21ba9ebdb719d5299e88607d722c190000000008b4830450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a0141046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339ffffffff021bff3d11000000001976a91404943fdd508053c75000106d3bc6e2754dbcff1988ac2f15de00000000001976a914a266436d2965547608b9e15d9032a7b9d64fa43188ac00000000");

            // and one which spends it (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
            var ch = new byte[] { 0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00 };
            byte[] vch = ch.Take(ch.Length - 1).ToArray();

            Transaction spendingTx = this.network.CreateTransaction(vch);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(uint256.Parse("0xb4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match tx hash");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            // byte-reversed tx hash
            filter.Insert(ParseHex("6bff7fcd4f8565ef406dd5d63d4ff94f318fe82027fd4dc451b04474019f74b4"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match manually serialized tx hash");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(ParseHex("30450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643ac4cb7cb3c462aced7f14711a01"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match input signature");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(ParseHex("046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe76036c339"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match input pub key");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(ParseHex("04943fdd508053c75000106d3bc6e2754dbcff19"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match output address");
            replacedert.True(filter.IsRelevantAndUpdate(spendingTx), "Simple Bloom filter didn't add output");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(ParseHex("a266436d2965547608b9e15d9032a7b9d64fa431"));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match output address");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(new OutPoint(uint256.Parse("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0));
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match COutPoint");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            var prevOutPoint = new OutPoint(uint256.Parse("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0);
            {
                byte[] data = prevOutPoint.ToBytes();
                filter.Insert(data);
            }
            replacedert.True(filter.IsRelevantAndUpdate(tx), "Simple Bloom filter didn't match manually serialized COutPoint");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(uint256.Parse("00000009e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436"));
            replacedert.True(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched random tx hash");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(ParseHex("0000006d2965547608b9e15d9032a7b9d64fa431"));
            replacedert.True(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched random address");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(new OutPoint(uint256.Parse("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 1));
            replacedert.True(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");

            filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            filter.Insert(new OutPoint(uint256.Parse("0x000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0));
            replacedert.True(!filter.IsRelevantAndUpdate(tx), "Simple Bloom filter matched COutPoint for an output we didn't care about");
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

private void replacedertMatch(Block block, List<uint256> vMatchedTxn, string txId, int expectedMerkleIndex, int expectedTxIndex)
        {
            uint256 id = uint256.Parse(txId);
            replacedert.True(vMatchedTxn[expectedMerkleIndex] == id);
            int actualIndexTx = Array.IndexOf(block.Transactions.Select(t => t.GetHash()).ToArray(), id);
            replacedert.True(actualIndexTx == expectedTxIndex);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_2()
        {
            // Random real block (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
            // With 4 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            // Match the first transaction
            filter.Insert(uint256.Parse("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            List<uint256> vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(vMatchedTxn.Count == 1);

            replacedertMatch(block, vMatchedTxn, "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70", 0, 0);

            // Match an output from the second transaction (the pubkey for address 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
            // This should match the third transaction because it spends the output matched
            // It also matches the fourth transaction, which spends to the pubkey again
            filter.Insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45af"));

            merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(vMatchedTxn.Count == 4);

            replacedertMatch(block, vMatchedTxn, "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70", 0, 0);
            replacedertMatch(block, vMatchedTxn, "0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56ebdcacd3069a5f", 1, 1);
            replacedertMatch(block, vMatchedTxn, "0x6b0f8a73a56c04b519f1883e8aafda643ba61a30bd1439969df21bea5f4e27e2", 2, 2);
            replacedertMatch(block, vMatchedTxn, "0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d7007663ace63cddb23", 3, 3);
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void StraxTestnetIsInitializedCorrectly()
        {
            Network network = this.straxTest;

            replacedert.Single(network.SeedNodes);

            replacedert.Equal("StraxTest", network.Name);
            replacedert.Equal(StraxNetwork.StraxRootFolderName, network.RootFolderName);
            replacedert.Equal(StraxNetwork.StraxDefaultConfigFilename, network.DefaultConfigFilename);
            replacedert.Equal(BitConverter.ToUInt32(Encoding.ASCII.GetBytes("TtrX")).ToString(), network.Magic.ToString());
            replacedert.Equal(27105, network.DefaultPort);
            replacedert.Equal(27104, network.DefaultRPCPort);
            replacedert.Equal(StraxNetwork.StratisMaxTimeOffsetSeconds, network.MaxTimeOffsetSeconds);
            replacedert.Equal(StraxNetwork.StratisDefaultMaxTipAgeInSeconds, network.MaxTipAge);
            replacedert.Equal(10000, network.MinTxFee);
            replacedert.Equal(10000, network.FallbackFee);
            replacedert.Equal(10000, network.MinRelayTxFee);
            replacedert.Equal("TSTRAX", network.CoinTicker);

            replacedert.Equal(2, network.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("tstrax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("tstrax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, network.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { (120) }, network.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (127) }, network.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (120 + 128) }, network.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xB2), (0x1E) }, network.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xAD), (0xE4) }, network.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, network.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, network.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2a }, network.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 23 }, network.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, network.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(210000, network.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(750, network.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(950, network.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(1000, network.Consensus.MajorityWindow);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Null(network.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("0000ffff00000000000000000000000000000000000000000000000000000000")), network.Consensus.PowLimit);
            replacedert.Null(network.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), network.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(45), network.Consensus.TargetSpacing);
            replacedert.False(network.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.False(network.Consensus.PowNoRetargeting);
            replacedert.Equal(2016, network.Consensus.MinerConfirmationWindow);
            replacedert.Equal(12500, network.Consensus.LastPOWBlock);
            replacedert.True(network.Consensus.IsProofOfStake);
            replacedert.Equal(1, network.Consensus.CoinType);
            replacedert.Equal(new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimit);
            replacedert.Equal(new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimitV2);
            replacedert.Null(network.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(50, network.Consensus.CoinbaseMaturity);
            replacedert.Equal(Money.Coins(130000000), network.Consensus.PremineReward);
            replacedert.Equal(2, network.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)500, network.Consensus.MaxReorgLength);
            replacedert.Equal(long.MaxValue, network.Consensus.MaxMoney);

            Block genesis = network.GetGenesis();
            replacedert.Equal(uint256.Parse("0x0000db68ff9e74fbaf7654bab4fa702c237318428fa9186055c243ddde6354ca"), genesis.GetHash());
            replacedert.Equal(uint256.Parse("0xfe6317d42149b091399e7f834ca32fd248f8f26f493c30a35d6eea692fe4fcad"), genesis.Header.HashMerkleRoot);
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void StraxRegTestIsInitializedCorrectly()
        {
            Network network = this.straxRegTest;

            replacedert.Empty(network.Checkpoints);
            replacedert.Empty(network.DNSSeeds);
            replacedert.Empty(network.SeedNodes);

            replacedert.Equal("StraxRegTest", network.Name);
            replacedert.Equal(StraxNetwork.StraxRootFolderName, network.RootFolderName);
            replacedert.Equal(StraxNetwork.StraxDefaultConfigFilename, network.DefaultConfigFilename);
            replacedert.Equal(BitConverter.ToUInt32(Encoding.ASCII.GetBytes("RtrX")), network.Magic);
            replacedert.Equal(37105, network.DefaultPort);
            replacedert.Equal(37104, network.DefaultRPCPort);
            replacedert.Equal(StraxNetwork.StratisMaxTimeOffsetSeconds, network.MaxTimeOffsetSeconds);
            replacedert.Equal(StraxNetwork.StratisDefaultMaxTipAgeInSeconds, network.MaxTipAge);
            replacedert.Equal(10000, network.MinTxFee);
            replacedert.Equal(10000, network.FallbackFee);
            replacedert.Equal(10000, network.MinRelayTxFee);
            replacedert.Equal("TSTRAX", network.CoinTicker);

            replacedert.Equal(2, network.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("tstrax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("tstrax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, network.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { (120) }, network.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (127) }, network.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (120 + 128) }, network.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xB2), (0x1E) }, network.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xAD), (0xE4) }, network.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, network.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, network.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2a }, network.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 23 }, network.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, network.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(210000, network.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(750, network.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(950, network.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(1000, network.Consensus.MajorityWindow);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Null(network.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), network.Consensus.PowLimit);
            replacedert.Null(network.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), network.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(45), network.Consensus.TargetSpacing);
            replacedert.True(network.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.True(network.Consensus.PowNoRetargeting);
            replacedert.Equal(144, network.Consensus.MinerConfirmationWindow);
            replacedert.Equal(12500, network.Consensus.LastPOWBlock);
            replacedert.True(network.Consensus.IsProofOfStake);
            replacedert.Equal(1, network.Consensus.CoinType);
            replacedert.Equal(new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimit);
            replacedert.Equal(new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimitV2);
            replacedert.Null(network.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(10, network.Consensus.CoinbaseMaturity);
            replacedert.Equal(Money.Coins(130000000), network.Consensus.PremineReward);
            replacedert.Equal(2, network.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)500, network.Consensus.MaxReorgLength);
            replacedert.Equal(long.MaxValue, network.Consensus.MaxMoney);

            Block genesis = network.GetGenesis();
            replacedert.Equal(uint256.Parse("0x77283cca51b83fe3bda9ce8966248613036b0dc55a707ce76ca7b79aaa9962e4"), genesis.GetHash());
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_1()
        {
            // Random real block (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af)
            // With 9 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            // Match the last transaction
            filter.Insert(uint256.Parse("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));

            MerkleBlock merkleBlock = block.Filter(filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            List<uint256> vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(vMatchedTxn.Count == 1);

            replacedertMatch(block, vMatchedTxn, "0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20", 0, 8);

            // Also match the 8th transaction
            filter.Insert(uint256.Parse("0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f168809cdfae1053"));
            merkleBlock = block.Filter(filter);
            vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(vMatchedTxn.Count == 2);

            replacedertMatch(block, vMatchedTxn, "0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20", 1, 8);
            replacedertMatch(block, vMatchedTxn, "0xdd1fd2a6fc16404faf339881a90adbde7f4f728691ac62e8f168809cdfae1053", 0, 7);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_2_with_update_none()
        {
            // Random real block (000000005a4ded781e667e06ceefafb71410b511fe0d5adc3e5a27ecbec34ae6)
            // With 4 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_NONE);
            // Match the first transaction
            filter.Insert(uint256.Parse("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            List<uint256> vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();

            replacedert.True(vMatchedTxn.Count == 1);

            replacedertMatch(block, vMatchedTxn, "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70", 0, 0);

            // Match an output from the second transaction (the pubkey for address 1DZTzaBHUDM7T3QvUKBz4qXMRpkg8jsfB5)
            // This should not match the third transaction though it spends the output matched
            // It will match the fourth transaction, which has another pay-to-pubkey output to the same address
            filter.Insert(ParseHex("044a656f065871a353f216ca26cef8dde2f03e8c16202d2e8ad769f02032cb86a5eb5e56842e92e19141d60a01928f8dd2c875a390f67c1f6c94cfc617c0ea45af"));

            merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();

            replacedert.True(vMatchedTxn.Count == 3);

            replacedertMatch(block, vMatchedTxn, "0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70", 0, 0);
            replacedertMatch(block, vMatchedTxn, "0x28204cad1d7fc1d199e8ef4fa22f182de6258a3eaafe1bbe56ebdcacd3069a5f", 1, 1);
            replacedertMatch(block, vMatchedTxn, "0x3c1d7e82342158e4109df2e0b6348b6e84e403d8b4046d7007663ace63cddb23", 2, 3);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_3_and_serialize()
        {
            // Random real block (000000000000dab0130bbcc991d3d7ae6b81aa6f50a798888dfe62337458dc45)
            // With one tx
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff08044c86041b020a02ffffffff0100f2052a01000000434104ecd3229b0571c3be876feaac0442a9f13c5a572742927af1dc623353ecf8c202225f64868137a18cdd85cbbb4c74fbccfd4f49639cf1bdc94a5672bb15ad5d4cac00000000"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            // Match the only transaction
            filter.Insert(uint256.Parse("0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));

            List<uint256> vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(vMatchedTxn.Count == 1);

            replacedertMatch(block, vMatchedTxn, "0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5", 0, 0);

            byte[] vch = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");

            replacedertEx.CollectionEquals(merkleBlock.ToBytes(), vch);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_4()
        {
            // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
            // With 7 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_ALL);
            // Match the last transaction
            filter.Insert(uint256.Parse("0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());

            List<uint256> vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();
            replacedert.True(vMatchedTxn.Count == 1);

            replacedertMatch(block, vMatchedTxn, "0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154", 0, 6);

            // Also match the 4th transaction
            filter.Insert(uint256.Parse("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"));
            merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.PartialMerkleTree.Check(block.Header.HashMerkleRoot));
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());
            vMatchedTxn = merkleBlock.PartialMerkleTree.GetMatchedTransactions().ToList();

            replacedert.True(vMatchedTxn.Count == 2);

            replacedertMatch(block, vMatchedTxn, "0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154", 1, 6);
            replacedertMatch(block, vMatchedTxn, "0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041", 0, 3);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_4_test_p2pubkey_only()
        {
            // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
            // With 7 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_P2PUBKEY_ONLY);
            // Match the generation pubkey
            filter.Insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a2252247d97a46a91"));
            // ...and the output address of the 4th transaction
            filter.Insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());

            // We should match the generation outpoint
            replacedert.True(filter.Contains(new OutPoint(uint256.Parse("0x147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"), 0)));
            // ... but not the 4th transaction's output (its not pay-2-pubkey)
            replacedert.True(!filter.Contains(new OutPoint(uint256.Parse("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"), 0)));
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void BitcoinTestnetIsInitializedCorrectly()
        {
            Network network = KnownNetworks.TestNet;

            replacedert.Equal(13, network.Checkpoints.Count);
            replacedert.Equal(3, network.DNSSeeds.Count);
            replacedert.Empty(network.SeedNodes);

            replacedert.Equal("TestNet", network.Name);
            replacedert.Equal(BitcoinMain.BitcoinRootFolderName, network.RootFolderName);
            replacedert.Equal(BitcoinMain.BitcoinDefaultConfigFilename, network.DefaultConfigFilename);
            replacedert.Equal(0x0709110B.ToString(), network.Magic.ToString());
            replacedert.Equal(18333, network.DefaultPort);
            replacedert.Equal(18332, network.DefaultRPCPort);
            replacedert.Equal(BitcoinMain.BitcoinMaxTimeOffsetSeconds, network.MaxTimeOffsetSeconds);
            replacedert.Equal(BitcoinMain.BitcoinDefaultMaxTipAgeInSeconds, network.MaxTipAge);
            replacedert.Equal(1000, network.MinTxFee);
            replacedert.Equal(20000, network.FallbackFee);
            replacedert.Equal(1000, network.MinRelayTxFee);
            replacedert.Equal("TBTC", network.CoinTicker);

            replacedert.Equal(2, network.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("tb").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("tb").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, network.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { 111 }, network.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (196) }, network.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (239) }, network.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x35), (0x87), (0xCF) }, network.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x35), (0x83), (0x94) }, network.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, network.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, network.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2b }, network.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 115 }, network.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, network.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(210000, network.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(51, network.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(75, network.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(100, network.Consensus.MajorityWindow);
            replacedert.Equal(21111, network.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(581885, network.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(330776, network.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Equal(new uint256("0x0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8"), network.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), network.Consensus.PowLimit);
            replacedert.Equal(new uint256("0x0000000000000000000000000000000000000000000000198b4def2baa9338d6"), network.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), network.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(10 * 60), network.Consensus.TargetSpacing);
            replacedert.True(network.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.False(network.Consensus.PowNoRetargeting);
            replacedert.Equal(2016, network.Consensus.MinerConfirmationWindow);
            replacedert.Equal(28, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1199145601), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1230767999), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Timeout);
            replacedert.Equal(0, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1456790400), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1493596800), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Timeout);
            replacedert.Equal(1, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1462060800), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1493596800), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Timeout);
            replacedert.Equal(1, network.Consensus.CoinType);
            replacedert.False(network.Consensus.IsProofOfStake);
            replacedert.Equal(new uint256("0x0000000000000037a8cd3e06cd5edbfe9dd1dbcc5dacab279376ef7cfc2b4c75"), network.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(100, network.Consensus.CoinbaseMaturity);
            replacedert.Equal(0, network.Consensus.PremineReward);
            replacedert.Equal(0, network.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(50), network.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Zero, network.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)0, network.Consensus.MaxReorgLength);
            replacedert.Equal(21000000 * Money.COIN, network.Consensus.MaxMoney);

            Block genesis = network.GetGenesis();
            replacedert.Equal(uint256.Parse("0x000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"), genesis.GetHash());
            replacedert.Equal(uint256.Parse("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"), genesis.Header.HashMerkleRoot);
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        public void StraxMainIsInitializedCorrectly()
        {
            Network network = this.straxMain;

            replacedert.Equal(2, network.DNSSeeds.Count);
            replacedert.Empty(network.SeedNodes);

            replacedert.Equal("StraxMain", network.Name);
            replacedert.Equal(StraxNetwork.StraxRootFolderName, network.RootFolderName);
            replacedert.Equal(StraxNetwork.StraxDefaultConfigFilename, network.DefaultConfigFilename);
            replacedert.Equal(BitConverter.ToUInt32(Encoding.ASCII.GetBytes("StrX")).ToString(), network.Magic.ToString());
            replacedert.Equal(17105, network.DefaultPort);
            replacedert.Equal(17104, network.DefaultRPCPort);
            replacedert.Equal(StraxNetwork.StratisMaxTimeOffsetSeconds, network.MaxTimeOffsetSeconds);
            replacedert.Equal(StraxNetwork.StratisDefaultMaxTipAgeInSeconds, network.MaxTipAge);
            replacedert.Equal(10000, network.MinTxFee);
            replacedert.Equal(10000, network.FallbackFee);
            replacedert.Equal(10000, network.MinRelayTxFee);
            replacedert.Equal("STRAX", network.CoinTicker);

            replacedert.Equal(2, network.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("strax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("strax").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, network.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { (75) }, network.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (140) }, network.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (75 + 128) }, network.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xB2), (0x1E) }, network.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xAD), (0xE4) }, network.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, network.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, network.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2a }, network.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 23 }, network.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, network.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(210000, network.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(750, network.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(950, network.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(1000, network.Consensus.MajorityWindow);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(0, network.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Null(network.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), network.Consensus.PowLimit);
            replacedert.Null(network.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), network.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(45), network.Consensus.TargetSpacing);
            replacedert.False(network.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.False(network.Consensus.PowNoRetargeting);
            replacedert.Equal(2016, network.Consensus.MinerConfirmationWindow);
            replacedert.Equal(675, network.Consensus.LastPOWBlock);
            replacedert.True(network.Consensus.IsProofOfStake);
            replacedert.Equal(105105, network.Consensus.CoinType);
            replacedert.Equal(new BigInteger(uint256.Parse("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimit);
            replacedert.Equal(new BigInteger(uint256.Parse("000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffff").ToBytes(false)), network.Consensus.ProofOfStakeLimitV2);
            replacedert.Null(network.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(50, network.Consensus.CoinbaseMaturity);
            replacedert.Equal(Money.Coins(124987850), network.Consensus.PremineReward);
            replacedert.Equal(2, network.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Coins(18), network.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)500, network.Consensus.MaxReorgLength);
            replacedert.Equal(long.MaxValue, network.Consensus.MaxMoney);

            Block genesis = network.GetGenesis();
            replacedert.Equal(uint256.Parse("0xebe158d09325c470276619ebc5f7f87c98c0ed4b211c46a17a6457655811d082"), genesis.GetHash());
            replacedert.Equal(uint256.Parse("0xdd91e99b7ca5eb97d9c41b867762d1f2db412ba4331efb61d138fce5d39b9084"), genesis.Header.HashMerkleRoot);
        }

19 Source : bloom_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Merkle_block_4_test_update_none()
        {
            // Random real block (000000000000b731f2eef9e8c63173adfb07e41bd53eb0ef0a6b720d6cb6dea4)
            // With 7 txes
            Block block = this.network.Consensus.ConsensusFactory.CreateBlock();
            block.ReadWrite(ParseHex("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"), this.network.Consensus.ConsensusFactory);

            var filter = new BloomFilter(10, 0.000001, 0, BloomFlags.UPDATE_NONE);
            // Match the generation pubkey
            filter.Insert(ParseHex("04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a2252247d97a46a91"));
            // ...and the output address of the 4th transaction
            filter.Insert(ParseHex("b6efd80d99179f4f4ff6f4dd0a007d018c385d21"));

            var merkleBlock = new MerkleBlock(block, filter);
            replacedert.True(merkleBlock.Header.GetHash() == block.GetHash());

            // We shouldn't match any outpoints (UPDATE_NONE)
            replacedert.True(!filter.Contains(new OutPoint(uint256.Parse("0x147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"), 0)));
            replacedert.True(!filter.Contains((new OutPoint(uint256.Parse("0x02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"), 0))));
        }

19 Source : hash_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void hash256()
        {
            replacedert.Equal(uint256.Parse("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"), this.networkMain.GetGenesis().GetHash());
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void BitcoinMainnetIsInitializedCorrectly()
        {
            replacedert.Equal(17, this.networkMain.Checkpoints.Count);
            replacedert.Equal(6, this.networkMain.DNSSeeds.Count);
            replacedert.Equal(512, this.networkMain.SeedNodes.Count);

            replacedert.Equal(NetworkRegistration.GetNetwork("main"), this.networkMain);
            replacedert.Equal(NetworkRegistration.GetNetwork("mainnet"), this.networkMain);

            replacedert.Equal("Main", this.networkMain.Name);
            replacedert.Equal(BitcoinMain.BitcoinRootFolderName, this.networkMain.RootFolderName);
            replacedert.Equal(BitcoinMain.BitcoinDefaultConfigFilename, this.networkMain.DefaultConfigFilename);
            replacedert.Equal(0xD9B4BEF9, this.networkMain.Magic);
            replacedert.Equal(8333, this.networkMain.DefaultPort);
            replacedert.Equal(8332, this.networkMain.DefaultRPCPort);
            replacedert.Equal(BitcoinMain.BitcoinMaxTimeOffsetSeconds, this.networkMain.MaxTimeOffsetSeconds);
            replacedert.Equal(BitcoinMain.BitcoinDefaultMaxTipAgeInSeconds, this.networkMain.MaxTipAge);
            replacedert.Equal(1000, this.networkMain.MinTxFee);
            replacedert.Equal(20000, this.networkMain.FallbackFee);
            replacedert.Equal(1000, this.networkMain.MinRelayTxFee);
            replacedert.Equal("BTC", this.networkMain.CoinTicker);

            replacedert.Equal(2, this.networkMain.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("bc").ToString(), this.networkMain.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("bc").ToString(), this.networkMain.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, this.networkMain.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { 0 }, this.networkMain.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (5) }, this.networkMain.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (128) }, this.networkMain.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, this.networkMain.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, this.networkMain.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xB2), (0x1E) }, this.networkMain.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x88), (0xAD), (0xE4) }, this.networkMain.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, this.networkMain.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, this.networkMain.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2a }, this.networkMain.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 23 }, this.networkMain.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, this.networkMain.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(210000, this.networkMain.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(750, this.networkMain.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(950, this.networkMain.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(1000, this.networkMain.Consensus.MajorityWindow);
            replacedert.Equal(227931, this.networkMain.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(388381, this.networkMain.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(363725, this.networkMain.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Equal(new uint256("0x000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8"), this.networkMain.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), this.networkMain.Consensus.PowLimit);
            replacedert.Equal(new uint256("0x0000000000000000000000000000000000000000002cb971dd56d1c583c20f90"), this.networkMain.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), this.networkMain.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(10 * 60), this.networkMain.Consensus.TargetSpacing);
            replacedert.False(this.networkMain.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.False(this.networkMain.Consensus.PowNoRetargeting);
            replacedert.Equal(2016, this.networkMain.Consensus.MinerConfirmationWindow);
            replacedert.Equal(28, this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1199145601), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1230767999), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Timeout);
            replacedert.Equal(0, this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1462060800), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1493596800), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Timeout);
            replacedert.Equal(1, this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(1479168000), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(1510704000), this.networkMain.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Timeout);
            replacedert.Equal(0, this.networkMain.Consensus.CoinType);
            replacedert.False(this.networkMain.Consensus.IsProofOfStake);
            replacedert.Equal(new uint256("0x0000000000000000000f1c54590ee18d15ec70e68c8cd4cfbadb1b4f11697eee"), this.networkMain.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(100, this.networkMain.Consensus.CoinbaseMaturity);
            replacedert.Equal(0, this.networkMain.Consensus.PremineReward);
            replacedert.Equal(0, this.networkMain.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(50), this.networkMain.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Zero, this.networkMain.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)0, this.networkMain.Consensus.MaxReorgLength);
            replacedert.Equal(21000000 * Money.COIN, this.networkMain.Consensus.MaxMoney);

            Block genesis = this.networkMain.GetGenesis();
            replacedert.Equal(uint256.Parse("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"), genesis.GetHash());
            replacedert.Equal(uint256.Parse("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"), genesis.Header.HashMerkleRoot);
        }

19 Source : NetworkTests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void BitcoinRegTestIsInitializedCorrectly()
        {
            Network network = KnownNetworks.RegTest;

            replacedert.Empty(network.Checkpoints);
            replacedert.Empty(network.DNSSeeds);
            replacedert.Empty(network.SeedNodes);

            replacedert.Equal("RegTest", network.Name);
            replacedert.Equal(BitcoinMain.BitcoinRootFolderName, network.RootFolderName);
            replacedert.Equal(BitcoinMain.BitcoinDefaultConfigFilename, network.DefaultConfigFilename);
            replacedert.Equal(0xDAB5BFFA, network.Magic);
            replacedert.Equal(18444, network.DefaultPort);
            replacedert.Equal(18332, network.DefaultRPCPort);
            replacedert.Equal(BitcoinMain.BitcoinMaxTimeOffsetSeconds, network.MaxTimeOffsetSeconds);
            replacedert.Equal(BitcoinMain.BitcoinDefaultMaxTipAgeInSeconds, network.MaxTipAge);
            replacedert.Equal(1000, network.MinTxFee);
            replacedert.Equal(20000, network.FallbackFee);
            replacedert.Equal(1000, network.MinRelayTxFee);
            replacedert.Equal("TBTC", network.CoinTicker);

            replacedert.Equal(2, network.Bech32Encoders.Length);
            replacedert.Equal(new Bech32Encoder("tb").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS].ToString());
            replacedert.Equal(new Bech32Encoder("tb").ToString(), network.Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS].ToString());

            replacedert.Equal(12, network.Base58Prefixes.Length);
            replacedert.Equal(new byte[] { 111 }, network.Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS]);
            replacedert.Equal(new byte[] { (196) }, network.Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS]);
            replacedert.Equal(new byte[] { (239) }, network.Base58Prefixes[(int)Base58Type.SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x01, 0x42 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_NO_EC]);
            replacedert.Equal(new byte[] { 0x01, 0x43 }, network.Base58Prefixes[(int)Base58Type.ENCRYPTED_SECRET_KEY_EC]);
            replacedert.Equal(new byte[] { (0x04), (0x35), (0x87), (0xCF) }, network.Base58Prefixes[(int)Base58Type.EXT_PUBLIC_KEY]);
            replacedert.Equal(new byte[] { (0x04), (0x35), (0x83), (0x94) }, network.Base58Prefixes[(int)Base58Type.EXT_SECRET_KEY]);
            replacedert.Equal(new byte[] { 0x2C, 0xE9, 0xB3, 0xE1, 0xFF, 0x39, 0xE2 }, network.Base58Prefixes[(int)Base58Type.PreplacedPHRASE_CODE]);
            replacedert.Equal(new byte[] { 0x64, 0x3B, 0xF6, 0xA8, 0x9A }, network.Base58Prefixes[(int)Base58Type.CONFIRMATION_CODE]);
            replacedert.Equal(new byte[] { 0x2b }, network.Base58Prefixes[(int)Base58Type.STEALTH_ADDRESS]);
            replacedert.Equal(new byte[] { 115 }, network.Base58Prefixes[(int)Base58Type.replacedET_ID]);
            replacedert.Equal(new byte[] { 0x13 }, network.Base58Prefixes[(int)Base58Type.COLORED_ADDRESS]);

            replacedert.Equal(150, network.Consensus.SubsidyHalvingInterval);
            replacedert.Equal(750, network.Consensus.MajorityEnforceBlockUpgrade);
            replacedert.Equal(950, network.Consensus.MajorityRejectBlockOutdated);
            replacedert.Equal(1000, network.Consensus.MajorityWindow);
            replacedert.Equal(100000000, network.Consensus.BuriedDeployments[BuriedDeployments.BIP34]);
            replacedert.Equal(100000000, network.Consensus.BuriedDeployments[BuriedDeployments.BIP65]);
            replacedert.Equal(100000000, network.Consensus.BuriedDeployments[BuriedDeployments.BIP66]);
            replacedert.Equal(new uint256(), network.Consensus.BIP34Hash);
            replacedert.Equal(new Target(new uint256("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")), network.Consensus.PowLimit);
            replacedert.Equal(uint256.Zero, network.Consensus.MinimumChainWork);
            replacedert.Equal(TimeSpan.FromSeconds(14 * 24 * 60 * 60), network.Consensus.PowTargetTimespan);
            replacedert.Equal(TimeSpan.FromSeconds(10 * 60), network.Consensus.TargetSpacing);
            replacedert.True(network.Consensus.PowAllowMinDifficultyBlocks);
            replacedert.True(network.Consensus.PowNoRetargeting);
            replacedert.Equal(144, network.Consensus.MinerConfirmationWindow);
            replacedert.Equal(28, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(0), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(999999999), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.TestDummy].Timeout);
            replacedert.Equal(0, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(0), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(999999999), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.CSV].Timeout);
            replacedert.Equal(1, network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Bit);
            replacedert.Equal(Utils.UnixTimeToDateTime(BIP9DeploymentsParameters.AlwaysActive), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].StartTime);
            replacedert.Equal(Utils.UnixTimeToDateTime(999999999), network.Consensus.BIP9Deployments[BitcoinBIP9Deployments.Segwit].Timeout);
            replacedert.Equal(0, network.Consensus.CoinType);
            replacedert.False(network.Consensus.IsProofOfStake);
            replacedert.Null(network.Consensus.DefaultreplacedumeValid);
            replacedert.Equal(100, network.Consensus.CoinbaseMaturity);
            replacedert.Equal(0, network.Consensus.PremineReward);
            replacedert.Equal(0, network.Consensus.PremineHeight);
            replacedert.Equal(Money.Coins(50), network.Consensus.ProofOfWorkReward);
            replacedert.Equal(Money.Zero, network.Consensus.ProofOfStakeReward);
            replacedert.Equal((uint)0, network.Consensus.MaxReorgLength);
            replacedert.Equal(21000000 * Money.COIN, network.Consensus.MaxMoney);

            Block genesis = network.GetGenesis();
            replacedert.Equal(uint256.Parse("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"), genesis.GetHash());
            replacedert.Equal(uint256.Parse("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"), genesis.Header.HashMerkleRoot);
        }

19 Source : pos_hash_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void hash256()
        {
            replacedert.Equal(uint256.Parse("0xebe158d09325c470276619ebc5f7f87c98c0ed4b211c46a17a6457655811d082"), this.stratisMain.GetGenesis().GetHash());
        }

19 Source : pos_hash_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void hashX13Genesis()
        {
            // genesis uses an x13 hash
            byte[] genesisHeader = Encoders.Hex.DecodeData("01000000000000000000000000000000000000000000000000000000000000000000000018157f44917c2514c1f339346200f8b27d8ffaae9d8205bfae51030bc26ba265b88ba557ffff0f1eddf21b00");
            uint256 genesisHash = HashX13.Instance.Hash(genesisHeader);
            replacedert.Equal(genesisHash, uint256.Parse("0x0000066e91e46e5a264d42c89e1204963b2ee6be230b443e9159020539d972af"));
        }

19 Source : pos_transaction_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void CanEstimatedFeesCorrectlyIfFeesChangeTransactionSize()
        {
            Script redeem = PayToMultiSigTemplate.Instance.GenerateScriptPubKey(2, new Key().PubKey, new Key().PubKey, new Key().PubKey);
            var transactionBuilder = new TransactionBuilder(this.stratisMain);
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 1), new TxOut("0.00010000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 2), new TxOut("0.00091824", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 3), new TxOut("0.00100000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 4), new TxOut("0.00100000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 5), new TxOut("0.00246414", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 6), new TxOut("0.00250980", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 7), new TxOut("0.01000000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(KnownNetworks.Main))).ToScriptCoin(redeem));
            transactionBuilder.Send(new Key().PubKey.GetAddress(KnownNetworks.Main), "0.01000000");
            transactionBuilder.SetChange(new Key().PubKey.GetAddress(KnownNetworks.Main));

            var feeRate = new FeeRate((long)32563);
            Money estimatedFeeBefore = transactionBuilder.EstimateFees(feeRate);
            //Adding the estimated fees will cause 6 more coins to be included, so let's verify the actual sent fees take that into account
            transactionBuilder.SendEstimatedFees(feeRate);
            Transaction tx = transactionBuilder.BuildTransaction(false);
            Money estimation = transactionBuilder.EstimateFees(tx, feeRate);
            replacedert.Equal(estimation, tx.GetFee(transactionBuilder.FindSpentCoins(tx)));
            replacedert.Equal(estimatedFeeBefore, estimation);
        }

19 Source : pos_transaction_tests.cs
with MIT License
from stratisproject

[Fact(Skip="This test would need all the sample transactions regenerated without the time field serialised")]
        [Trait("UnitTest", "UnitTest")]
        //http://brainwallet.org/#tx
        public void CanParseTransaction()
        {
            TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataPosFolder("can_parse_transaction.json"));

            foreach (dynamic test in tests.Select(t => t.GetDynamic(0)))
            {
                string raw = test.Raw;
                Transaction tx = this.stratisMain.CreateTransaction(raw);
                replacedert.Equal((int)test.JSON.vin_sz, tx.Inputs.Count);
                replacedert.Equal((int)test.JSON.vout_sz, tx.Outputs.Count);
                replacedert.Equal((uint)test.JSON.lock_time, (uint)tx.LockTime);

                for (int i = 0; i < tx.Inputs.Count; i++)
                {
                    TxIn actualVIn = tx.Inputs[i];
                    dynamic expectedVIn = test.JSON.@in[i];
                    replacedert.Equal(uint256.Parse((string)expectedVIn.prev_out.hash), actualVIn.PrevOut.Hash);
                    replacedert.Equal((uint)expectedVIn.prev_out.n, actualVIn.PrevOut.N);
                    if (expectedVIn.sequence != null)
                        replacedert.Equal((uint)expectedVIn.sequence, (uint)actualVIn.Sequence);
                    replacedert.Equal((string)expectedVIn.scriptSig, actualVIn.ScriptSig.ToString());
                    //Can parse the string
                    replacedert.Equal((string)expectedVIn.scriptSig, (string)expectedVIn.scriptSig.ToString());
                }

                for (int i = 0; i < tx.Outputs.Count; i++)
                {
                    TxOut actualVOut = tx.Outputs[i];
                    dynamic expectedVOut = test.JSON.@out[i];
                    replacedert.Equal((string)expectedVOut.scriptPubKey, actualVOut.ScriptPubKey.ToString());
                    replacedert.Equal(Money.Parse((string)expectedVOut.value), actualVOut.Value);
                }
                string hash = (string)test.JSON.hash;
                var expectedHash = new uint256(Encoders.Hex.DecodeData(hash), false);
                replacedert.Equal(expectedHash, tx.GetHash());
            }
        }

19 Source : pos_transaction_tests.cs
with MIT License
from stratisproject

private void tx_valid()
        {
            // test is disabled for now
            // todo: get test data for the stratis blockchain

            // Read tests from test/data/tx_valid.json
            // Format is an array of arrays
            // Inner arrays are either [ "comment" ]
            // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
            // ... where all scripts are stringified scripts.
            TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataPosFolder("tx_valid.json"));
            foreach (TestCase test in tests)
            {
                string strTest = test.ToString();
                //Skip comments
                if (!(test[0] is JArray))
                    continue;
                var inputs = (JArray)test[0];
                if (test.Count != 3 || !(test[1] is string) || !(test[2] is string))
                {
                    replacedert.False(true, "Bad test: " + strTest);
                    continue;
                }

                var mapprevOutScriptPubKeys = new Dictionary<OutPoint, Script>();
                var mapprevOutScriptPubKeysAmount = new Dictionary<OutPoint, Money>();
                foreach (JToken vinput in inputs)
                {
                    var outpoint = new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()));
                    mapprevOutScriptPubKeys[outpoint] = Script_Tests.ParseScript(vinput[2].ToString());
                    if (vinput.Count() >= 4)
                        mapprevOutScriptPubKeysAmount[outpoint] = Money.Satoshis(vinput[3].Value<long>());
                }

                Transaction tx = this.stratisMain.CreateTransaction((string)test[1]);


                for (int i = 0; i < tx.Inputs.Count; i++)
                {
                    if (!mapprevOutScriptPubKeys.ContainsKey(tx.Inputs[i].PrevOut))
                    {
                        replacedert.False(true, "Bad test: " + strTest);
                        continue;
                    }

                    bool valid = Script.VerifyScript(this.stratisMain,
                        mapprevOutScriptPubKeys[tx.Inputs[i].PrevOut],
                        tx,
                        i,
                        mapprevOutScriptPubKeysAmount.TryGet(tx.Inputs[i].PrevOut),
                        ParseFlags(test[2].ToString())
                        , 0);
                    replacedert.True(valid, strTest + " failed");
                    replacedert.True(tx.Check() == TransactionCheckResult.Success);
                }
            }
        }

19 Source : pos_transaction_tests.cs
with MIT License
from stratisproject

private void Tx_invalid()
        {
            // test is disabled for now
            // todo: get test data for the stratis blockchain

            // Read tests from test/data/tx_valid.json
            // Format is an array of arrays
            // Inner arrays are either [ "comment" ]
            // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
            // ... where all scripts are stringified scripts.
            TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataPosFolder("tx_invalid.json"));
            string comment = null;
            foreach (TestCase test in tests)
            {
                string strTest = test.ToString();
                //Skip comments
                if (!(test[0] is JArray))
                {
                    comment = test[0].ToString();
                    continue;
                }
                var inputs = (JArray)test[0];
                if (test.Count != 3 || !(test[1] is string) || !(test[2] is string))
                {
                    replacedert.False(true, "Bad test: " + strTest);
                    continue;
                }
                var mapprevOutScriptPubKeys = new Dictionary<OutPoint, Script>();
                var mapprevOutScriptPubKeysAmount = new Dictionary<OutPoint, Money>();
                foreach (JToken vinput in inputs)
                {
                    var outpoint = new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()));
                    mapprevOutScriptPubKeys[new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()))] = Script_Tests.ParseScript(vinput[2].ToString());
                    if (vinput.Count() >= 4)
                        mapprevOutScriptPubKeysAmount[outpoint] = Money.Satoshis(vinput[3].Value<int>());
                }

                Transaction tx = this.stratisMain.CreateTransaction((string)test[1]);

                bool fValid = true;
                fValid = tx.Check() == TransactionCheckResult.Success;
                for (int i = 0; i < tx.Inputs.Count && fValid; i++)
                {
                    if (!mapprevOutScriptPubKeys.ContainsKey(tx.Inputs[i].PrevOut))
                    {
                        replacedert.False(true, "Bad test: " + strTest);
                        continue;
                    }

                    fValid = Script.VerifyScript(this.stratisMain,
                       mapprevOutScriptPubKeys[tx.Inputs[i].PrevOut],
                       tx,
                       i,
                       mapprevOutScriptPubKeysAmount.TryGet(tx.Inputs[i].PrevOut),
                       ParseFlags(test[2].ToString())
                       , 0);
                }
                if (fValid)
                    Debugger.Break();
                replacedert.True(!fValid, strTest + " failed");
            }
        }

19 Source : transaction_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void CanEstimatedFeesCorrectlyIfFeesChangeTransactionSize()
        {
            Script redeem = PayToMultiSigTemplate.Instance.GenerateScriptPubKey(2, new Key().PubKey, new Key().PubKey, new Key().PubKey);
            var transactionBuilder = new TransactionBuilder(this.networkMain);
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 1), new TxOut("0.00010000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 2), new TxOut("0.00091824", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 3), new TxOut("0.00100000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 4), new TxOut("0.00100000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 5), new TxOut("0.00246414", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 6), new TxOut("0.00250980", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.AddCoins(new Coin(new OutPoint(uint256.Parse("75425c904289f21feef0cffab2081ba22030b633623115adf0780edad443e6c7"), 7), new TxOut("0.01000000", PayToScriptHashTemplate.Instance.GenerateScriptPubKey(redeem).GetDestinationAddress(this.networkMain))).ToScriptCoin(redeem));
            transactionBuilder.Send(new Key().PubKey.GetAddress(this.networkMain), "0.01000000");
            transactionBuilder.SetChange(new Key().PubKey.GetAddress(this.networkMain));

            var feeRate = new FeeRate((long)32563);
            Money estimatedFeeBefore = transactionBuilder.EstimateFees(feeRate);
            //Adding the estimated fees will cause 6 more coins to be included, so let's verify the actual sent fees take that into account
            transactionBuilder.SendEstimatedFees(feeRate);
            Transaction tx = transactionBuilder.BuildTransaction(false);
            Money estimation = transactionBuilder.EstimateFees(tx, feeRate);
            replacedert.Equal(estimation, tx.GetFee(transactionBuilder.FindSpentCoins(tx)));
            replacedert.Equal(estimatedFeeBefore, estimation);
        }

19 Source : transaction_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Tx_Invalid()
        {
            // Read tests from test/data/tx_valid.json
            // Format is an array of arrays
            // Inner arrays are either [ "comment" ]
            // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
            // ... where all scripts are stringified scripts.
            TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataFolder("tx_invalid.json"));
            string comment = null;
            foreach (TestCase test in tests)
            {
                string strTest = test.ToString();
                //Skip comments
                if (!(test[0] is JArray))
                {
                    comment = test[0].ToString();
                    continue;
                }
                var inputs = (JArray)test[0];
                if (test.Count != 3 || !(test[1] is string) || !(test[2] is string))
                {
                    replacedert.False(true, "Bad test: " + strTest);
                    continue;
                }
                var mapprevOutScriptPubKeys = new Dictionary<OutPoint, Script>();
                var mapprevOutScriptPubKeysAmount = new Dictionary<OutPoint, Money>();
                foreach (JToken vinput in inputs)
                {
                    var outpoint = new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()));
                    mapprevOutScriptPubKeys[new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()))] = Script_Tests.ParseScript(vinput[2].ToString());
                    if (vinput.Count() >= 4)
                        mapprevOutScriptPubKeysAmount[outpoint] = Money.Satoshis(vinput[3].Value<int>());
                }

                Transaction tx = this.networkMain.CreateTransaction((string)test[1]);

                bool fValid = true;
                fValid = tx.Check() == TransactionCheckResult.Success;
                for (int i = 0; i < tx.Inputs.Count && fValid; i++)
                {
                    if (!mapprevOutScriptPubKeys.ContainsKey(tx.Inputs[i].PrevOut))
                    {
                        replacedert.False(true, "Bad test: " + strTest);
                        continue;
                    }

                    fValid = Script.VerifyScript(KnownNetworks.Main,
                       mapprevOutScriptPubKeys[tx.Inputs[i].PrevOut],
                       tx,
                       i,
                       mapprevOutScriptPubKeysAmount.TryGet(tx.Inputs[i].PrevOut),
                       ParseFlags(test[2].ToString())
                       , 0);
                }
                if (fValid)
                    Debugger.Break();
                replacedert.True(!fValid, strTest + " failed");
            }
        }

19 Source : uint256_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        public void uintTests()
        {
            var v = new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
            var v2 = new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
            var vless = new uint256("00000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffe");
            var vplus = new uint256("00000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

            replacedert.Equal("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", v.ToString());
            replacedert.Equal(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v);
            replacedert.Equal(new uint256("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v);
            replacedert.Equal(uint256.Parse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), v);
            replacedert.True(v < vplus);
            replacedert.True(v > vless);
            uint256 unused;
            replacedert.True(uint256.TryParse("0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.True(uint256.TryParse("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.True(uint256.TryParse("00000000ffffFFfFffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.False(uint256.TryParse("00000000gfffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.False(uint256.TryParse("100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.False(uint256.TryParse("1100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff", out unused));
            replacedert.Throws<FormatException>(() => uint256.Parse("1100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
            replacedert.Throws<FormatException>(() => uint256.Parse("100000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
            uint256.Parse("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
            replacedert.Throws<FormatException>(() => uint256.Parse("000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));

            replacedert.True(v >= v2);
            replacedert.True(v <= v2);
            replacedert.False(v < v2);
            replacedert.False(v > v2);

            replacedert.True(v.ToBytes()[0] == 0xFF);
            replacedert.True(v.ToBytes(false)[0] == 0x00);

            replacedertEquals(v, new uint256(v.ToBytes()));
            replacedertEquals(v, new uint256(v.ToBytes(false), false));

            replacedert.Equal(0xFF, v.GetByte(0));
            replacedert.Equal(0x00, v.GetByte(31));
            replacedert.Equal(0x39, new uint256("39000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffff").GetByte(31));
            replacedert.Throws<ArgumentOutOfRangeException>(() => v.GetByte(32));
        }

19 Source : NodeController.cs
with MIT License
from stratisproject

[Route("getblockheader")]
        [HttpGet]
        public IActionResult GetBlockHeader([FromQuery] string hash, bool isJsonFormat = true)
        {
            try
            {
                Guard.NotEmpty(hash, nameof(hash));

                this.logger.LogDebug("GetBlockHeader {0}", hash);
                if (!isJsonFormat)
                {
                    this.logger.LogError("Binary serialization is not supported.");
                    throw new NotImplementedException();
                }

                BlockHeaderModel model = null;
                BlockHeader blockHeader = this.chainIndexer?.GetHeader(uint256.Parse(hash))?.Header;
                if (blockHeader != null)
                {
                    model = new BlockHeaderModel(blockHeader);
                }

                return this.Json(model);
            }
            catch (Exception e)
            {
                this.logger.LogError("Exception occurred: {0}", e.ToString());
                return ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, e.Message, e.ToString());
            }
        }

19 Source : transaction_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("Core", "Core")]
        public void Tx_Valid()
        {
            // Read tests from test/data/tx_valid.json
            // Format is an array of arrays
            // Inner arrays are either [ "comment" ]
            // or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
            // ... where all scripts are stringified scripts.
            TestCase[] tests = TestCase.read_json(TestDataLocations.GetFileFromDataFolder("tx_valid.json"));
            foreach (TestCase test in tests)
            {
                string strTest = test.ToString();
                //Skip comments
                if (!(test[0] is JArray))
                    continue;
                var inputs = (JArray)test[0];
                if (test.Count != 3 || !(test[1] is string) || !(test[2] is string))
                {
                    replacedert.False(true, "Bad test: " + strTest);
                    continue;
                }

                var mapprevOutScriptPubKeys = new Dictionary<OutPoint, Script>();
                var mapprevOutScriptPubKeysAmount = new Dictionary<OutPoint, Money>();
                foreach (JToken vinput in inputs)
                {
                    var outpoint = new OutPoint(uint256.Parse(vinput[0].ToString()), int.Parse(vinput[1].ToString()));
                    mapprevOutScriptPubKeys[outpoint] = Script_Tests.ParseScript(vinput[2].ToString());
                    if (vinput.Count() >= 4)
                        mapprevOutScriptPubKeysAmount[outpoint] = Money.Satoshis(vinput[3].Value<long>());
                }

                Transaction tx = this.networkMain.CreateTransaction((string)test[1]);

                for (int i = 0; i < tx.Inputs.Count; i++)
                {
                    if (!mapprevOutScriptPubKeys.ContainsKey(tx.Inputs[i].PrevOut))
                    {
                        replacedert.False(true, "Bad test: " + strTest);
                        continue;
                    }

                    bool valid = Script.VerifyScript(KnownNetworks.Main,
                        mapprevOutScriptPubKeys[tx.Inputs[i].PrevOut],
                        tx,
                        i,
                        mapprevOutScriptPubKeysAmount.TryGet(tx.Inputs[i].PrevOut),
                        ParseFlags(test[2].ToString())
                        , 0);
                    replacedert.True(valid, strTest + " failed");
                    replacedert.True(tx.Check() == TransactionCheckResult.Success);
                }
            }
        }

19 Source : util_tests.cs
with MIT License
from stratisproject

[Fact]
        [Trait("UnitTest", "UnitTest")]
        //https://en.bitcoin.it/wiki/Difficulty
        public void CanReadConvertTargetToDifficulty()
        {
            var packed = new Target(TestUtils.ParseHex("1b0404cb"));
            var unpacked = new Target(uint256.Parse("00000000000404CB000000000000000000000000000000000000000000000000"));

            replacedert.Equal(packed, unpacked);
            replacedert.Equal(packed, new Target(0x1b0404cb));

            packed = new Target(TestUtils.ParseHex("1b8404cb"));
            replacedert.True(packed.ToBigInteger().CompareTo(BigInteger.Zero) < 0);
            replacedert.Equal(packed, new Target(0x1b8404cb));

            packed = new Target(TestUtils.ParseHex("1d00ffff"));
            replacedert.Equal(1, packed.Difficulty);
            replacedert.Equal(Target.Difficulty1, packed);

            packed = new Target(TestUtils.ParseHex("1b0404cb"));
            replacedert.Equal(16307.420938523983D, packed.Difficulty, "420938523983".Length);

            replacedert.Equal(packed, new Target((uint)0x1b0404cb));
            replacedert.Equal((uint)packed, (uint)0x1b0404cb);

            packed = new Target(0x1d00ffff);
            replacedert.Equal((uint)packed, (uint)0x1d00ffff);

            //Check http://blockchain.info/block-index/392672/0000000000000000511e193e22d2dfc02aea8037988f0c58e9834f4550e97702
            packed = new Target(419470732);
            replacedert.Equal(6978842649.592383, packed.Difficulty, "592383".Length);
            replacedert.Equal((uint)packed, (uint)419470732);
            replacedert.True(uint256.Parse("0x0000000000000000511e193e22d2dfc02aea8037988f0c58e9834f4550e97702") < packed.ToUInt256());

            //Check http://blockchain.info/block-index/394713/0000000000000000729a4a7e084c90f932d038c407a6535a51dfecdfba1c8906
            replacedert.True(uint256.Parse("0x0000000000000000729a4a7e084c90f932d038c407a6535a51dfecdfba1c8906 ") < new Target(419470732).ToUInt256());

            Block genesis = this.networkMain.GetGenesis();
            replacedert.True(genesis.GetHash() < genesis.Header.Bits.ToUInt256());
            replacedert.True(Target.Difficulty1 == Target.Difficulty1);
        }

See More Examples