Exemple #1
0
        public bool TryAddUnspentTx(UnspentTx unspentTx)
        {
            CheckWriteTransaction();

            try
            {
                unspentTransactions.Modify(x => x.Add(unspentTx.TxHash, unspentTx));
                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }
Exemple #2
0
        public bool TryAddBlockUnmintedTxes(UInt256 blockHash, IImmutableList <UnmintedTx> unmintedTxes)
        {
            CheckWriteTransaction();

            try
            {
                blockUnmintedTxes.Modify(x => x.Add(blockHash, unmintedTxes));
                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }
Exemple #3
0
        public bool TryAddBlockSpentTxes(int blockIndex, BlockSpentTxes spentTxes)
        {
            CheckWriteTransaction();

            try
            {
                blockSpentTxes.Modify(x => x.Add(blockIndex, spentTxes));
                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }
Exemple #4
0
        public bool TryAddUnspentTxOutput(TxOutputKey txOutputKey, TxOutput txOutput)
        {
            CheckWriteTransaction();

            try
            {
                unspentTxOutputs.Modify(x => x.Add(txOutputKey, txOutput));
                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }
Exemple #5
0
        public bool TryAddHeader(ChainedHeader header)
        {
            CheckWriteTransaction();

            try
            {
                headers.Modify(x => x.Add(header.Hash, header));
                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }
Exemple #6
0
        public bool TryAddTransaction(UnconfirmedTx unconfirmedTx)
        {
            CheckWriteTransaction();

            try
            {
                unconfirmedTxes.Modify(x => x.Add(unconfirmedTx.Hash, unconfirmedTx));

                // update index of txes spending each input's prev tx
                for (var inputIndex = 0; inputIndex < unconfirmedTx.Transaction.Inputs.Length; inputIndex++)
                {
                    var input = unconfirmedTx.Transaction.Inputs[inputIndex];

                    unconfirmedTxesByPrevTxOutputKey.Modify(_ => { });
                    ImmutableDictionary <UInt256, UnconfirmedTx> .Builder unconfirmedTxes;
                    if (unconfirmedTxesByPrevTxOutputKey.Value.TryGetValue(input.PrevTxOutputKey, out unconfirmedTxes))
                    {
                        // ensure a copy of the builder is modified or underlying storage will see uncomitted state
                        unconfirmedTxes = unconfirmedTxes.ToImmutable().ToBuilder();
                    }
                    else
                    {
                        unconfirmedTxes = ImmutableDictionary.CreateBuilder <UInt256, UnconfirmedTx>();
                    }

                    unconfirmedTxes.Add(unconfirmedTx.Hash, unconfirmedTx);
                    unconfirmedTxesByPrevTxOutputKey.Value[input.PrevTxOutputKey] = unconfirmedTxes;
                }

                return(true);
            }
            catch (ArgumentException)
            {
                return(false);
            }
        }